_ZN4wabt3ClzEj:
  120|  1.76M|inline int Clz(unsigned x) { return x ? __builtin_clz(x) : sizeof(x) * 8; }
  ------------------
  |  Branch (120:37): [True: 1.71M, False: 54.7k]
  ------------------
_ZN4wabt3ClzEm:
  121|  2.49M|inline int Clz(unsigned long x) { return x ? __builtin_clzl(x) : sizeof(x) * 8; }
  ------------------
  |  Branch (121:42): [True: 2.43M, False: 58.3k]
  ------------------

_ZN4wabt7BindingC2ERKNS_8LocationEj:
   34|   745k|  Binding(const Location& loc, Index index) : loc(loc), index(index) {}
_ZNK4wabt11BindingHash9FindIndexERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   52|   192k|  Index FindIndex(const std::string& name) const {
   53|   192k|    auto iter = find(name);
   54|   192k|    return iter != end() ? iter->second.index : kInvalidIndex;
  ------------------
  |  Branch (54:12): [True: 15.0k, False: 177k]
  ------------------
   55|   192k|  }

_ZN4wabt8dyn_castINS_15FuncModuleFieldENS_11ModuleFieldEEEPT_PT0_:
   88|  1.70M|Derived* dyn_cast(Base* base) {
   89|  1.70M|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 987k, False: 717k]
  ------------------
   90|  1.70M|};
_ZN4wabt3isaINS_15FuncModuleFieldENS_11ModuleFieldEEEbPKT0_:
   65|  1.70M|bool isa(const Base* base) {
   66|  1.70M|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.70M|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.70M|  return Derived::classof(base);
   68|  1.70M|}
_ZN4wabt8dyn_castINS_14TagModuleFieldENS_11ModuleFieldEEEPT_PT0_:
   88|   717k|Derived* dyn_cast(Base* base) {
   89|   717k|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 0, False: 717k]
  ------------------
   90|   717k|};
_ZN4wabt3isaINS_14TagModuleFieldENS_11ModuleFieldEEEbPKT0_:
   65|   717k|bool isa(const Base* base) {
   66|   717k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   717k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   717k|  return Derived::classof(base);
   68|   717k|}
_ZN4wabt8dyn_castINS_17ImportModuleFieldENS_11ModuleFieldEEEPT_PT0_:
   88|   717k|Derived* dyn_cast(Base* base) {
   89|   717k|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 68.7k, False: 648k]
  ------------------
   90|   717k|};
_ZN4wabt3isaINS_17ImportModuleFieldENS_11ModuleFieldEEEbPKT0_:
   65|   717k|bool isa(const Base* base) {
   66|   717k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   717k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   717k|  return Derived::classof(base);
   68|   717k|}
_ZN4wabt8dyn_castINS_10FuncImportENS_6ImportEEEPT_PT0_:
   88|  68.7k|Derived* dyn_cast(Base* base) {
   89|  68.7k|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 6.14k, False: 62.5k]
  ------------------
   90|  68.7k|};
_ZN4wabt3isaINS_10FuncImportENS_6ImportEEEbPKT0_:
   65|   142k|bool isa(const Base* base) {
   66|   142k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   142k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   142k|  return Derived::classof(base);
   68|   142k|}
_ZN4wabt8dyn_castINS_9TagImportENS_6ImportEEEPT_PT0_:
   88|  62.5k|Derived* dyn_cast(Base* base) {
   89|  62.5k|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 61.8k, False: 766]
  ------------------
   90|  62.5k|};
_ZN4wabt3isaINS_9TagImportENS_6ImportEEEbPKT0_:
   65|   126k|bool isa(const Base* base) {
   66|   126k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   126k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   126k|  return Derived::classof(base);
   68|   126k|}
_ZN4wabt4castINS_17ExportModuleFieldENS_11ModuleFieldEEEPT_PT0_:
   77|  42.4k|Derived* cast(Base* base) {
   78|  42.4k|  assert(isa<Derived>(base));
   79|  42.4k|  return static_cast<Derived*>(base);
   80|  42.4k|};
_ZN4wabt3isaINS_17ExportModuleFieldENS_11ModuleFieldEEEbPKT0_:
   65|  84.9k|bool isa(const Base* base) {
   66|  84.9k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  84.9k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  84.9k|  return Derived::classof(base);
   68|  84.9k|}
_ZN4wabt3isaINS_13ModuleCommandENS_7CommandEEEbPKT0_:
   65|    108|bool isa(const Base* base) {
   66|    108|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    108|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    108|  return Derived::classof(base);
   68|    108|}
_ZN4wabt4castINS_13ModuleCommandENS_7CommandEEENSt3__110unique_ptrIT_NS3_14default_deleteIS5_EEEEONS4_IT0_NS6_IS9_EEEE:
  102|     54|std::unique_ptr<Derived> cast(std::unique_ptr<Base>&& base) {
  103|     54|  assert(isa<Derived>(base.get()));
  104|     54|  return std::unique_ptr<Derived>(static_cast<Derived*>(base.release()));
  105|     54|};
_ZN4wabt4castINS_16TextScriptModuleENS_12ScriptModuleEEEPT_PT0_:
   77|     54|Derived* cast(Base* base) {
   78|     54|  assert(isa<Derived>(base));
   79|     54|  return static_cast<Derived*>(base);
   80|     54|};
_ZN4wabt3isaINS_16TextScriptModuleENS_12ScriptModuleEEEbPKT0_:
   65|     54|bool isa(const Base* base) {
   66|     54|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|     54|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|     54|  return Derived::classof(base);
   68|     54|}
_ZN4wabt4castINS_7TryExprENS_4ExprEEEPT_PT0_:
   77|   154k|Derived* cast(Base* base) {
   78|   154k|  assert(isa<Derived>(base));
   79|   154k|  return static_cast<Derived*>(base);
   80|   154k|};
_ZN4wabt3isaINS_7TryExprENS_4ExprEEEbPKT0_:
   65|   154k|bool isa(const Base* base) {
   66|   154k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   154k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   154k|  return Derived::classof(base);
   68|   154k|}
_ZN4wabt4castINS_6IfExprENS_4ExprEEEPT_PT0_:
   77|  13.0k|Derived* cast(Base* base) {
   78|  13.0k|  assert(isa<Derived>(base));
   79|  13.0k|  return static_cast<Derived*>(base);
   80|  13.0k|};
_ZN4wabt3isaINS_6IfExprENS_4ExprEEEbPKT0_:
   65|  13.0k|bool isa(const Base* base) {
   66|  13.0k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  13.0k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  13.0k|  return Derived::classof(base);
   68|  13.0k|}
_ZN4wabt4castINS_13BlockExprBaseILNS_8ExprTypeE8EEENS_4ExprEEEPT_PT0_:
   77|  22.1k|Derived* cast(Base* base) {
   78|  22.1k|  assert(isa<Derived>(base));
   79|  22.1k|  return static_cast<Derived*>(base);
   80|  22.1k|};
_ZN4wabt3isaINS_13BlockExprBaseILNS_8ExprTypeE8EEENS_4ExprEEEbPKT0_:
   65|  22.1k|bool isa(const Base* base) {
   66|  22.1k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  22.1k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  22.1k|  return Derived::classof(base);
   68|  22.1k|}
_ZN4wabt4castINS_13BlockExprBaseILNS_8ExprTypeE27EEENS_4ExprEEEPT_PT0_:
   77|   119k|Derived* cast(Base* base) {
   78|   119k|  assert(isa<Derived>(base));
   79|   119k|  return static_cast<Derived*>(base);
   80|   119k|};
_ZN4wabt3isaINS_13BlockExprBaseILNS_8ExprTypeE27EEENS_4ExprEEEbPKT0_:
   65|   119k|bool isa(const Base* base) {
   66|   119k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   119k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   119k|  return Derived::classof(base);
   68|   119k|}
_ZN4wabt4castINS_12TryTableExprENS_4ExprEEEPT_PT0_:
   77|  7.21k|Derived* cast(Base* base) {
   78|  7.21k|  assert(isa<Derived>(base));
   79|  7.21k|  return static_cast<Derived*>(base);
   80|  7.21k|};
_ZN4wabt3isaINS_12TryTableExprENS_4ExprEEEbPKT0_:
   65|  7.21k|bool isa(const Base* base) {
   66|  7.21k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  7.21k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  7.21k|  return Derived::classof(base);
   68|  7.21k|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE0EEENS_4ExprEEEPT_PT0_:
   77|    564|Derived* cast(Base* base) {
   78|    564|  assert(isa<Derived>(base));
   79|    564|  return static_cast<Derived*>(base);
   80|    564|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE0EEENS_4ExprEEEbPKT0_:
   65|    564|bool isa(const Base* base) {
   66|    564|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    564|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    564|  return Derived::classof(base);
   68|    564|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE3EEENS_4ExprEEEPT_PT0_:
   77|  1.12k|Derived* cast(Base* base) {
   78|  1.12k|  assert(isa<Derived>(base));
   79|  1.12k|  return static_cast<Derived*>(base);
   80|  1.12k|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE3EEENS_4ExprEEEbPKT0_:
   65|  1.12k|bool isa(const Base* base) {
   66|  1.12k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.12k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.12k|  return Derived::classof(base);
   68|  1.12k|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE1EEENS_4ExprEEEPT_PT0_:
   77|  1.70k|Derived* cast(Base* base) {
   78|  1.70k|  assert(isa<Derived>(base));
   79|  1.70k|  return static_cast<Derived*>(base);
   80|  1.70k|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE1EEENS_4ExprEEEbPKT0_:
   65|  1.70k|bool isa(const Base* base) {
   66|  1.70k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.70k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.70k|  return Derived::classof(base);
   68|  1.70k|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE2EEENS_4ExprEEEPT_PT0_:
   77|    197|Derived* cast(Base* base) {
   78|    197|  assert(isa<Derived>(base));
   79|    197|  return static_cast<Derived*>(base);
   80|    197|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE2EEENS_4ExprEEEbPKT0_:
   65|    197|bool isa(const Base* base) {
   66|    197|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    197|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    197|  return Derived::classof(base);
   68|    197|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE6EEENS_4ExprEEEPT_PT0_:
   77|    514|Derived* cast(Base* base) {
   78|    514|  assert(isa<Derived>(base));
   79|    514|  return static_cast<Derived*>(base);
   80|    514|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE6EEENS_4ExprEEEbPKT0_:
   65|    514|bool isa(const Base* base) {
   66|    514|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    514|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    514|  return Derived::classof(base);
   68|    514|}
_ZN4wabt4castINS_15AtomicFenceExprENS_4ExprEEEPT_PT0_:
   77|    746|Derived* cast(Base* base) {
   78|    746|  assert(isa<Derived>(base));
   79|    746|  return static_cast<Derived*>(base);
   80|    746|};
_ZN4wabt3isaINS_15AtomicFenceExprENS_4ExprEEEbPKT0_:
   65|    746|bool isa(const Base* base) {
   66|    746|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    746|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    746|  return Derived::classof(base);
   68|    746|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE4EEENS_4ExprEEEPT_PT0_:
   77|    666|Derived* cast(Base* base) {
   78|    666|  assert(isa<Derived>(base));
   79|    666|  return static_cast<Derived*>(base);
   80|    666|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE4EEENS_4ExprEEEbPKT0_:
   65|    666|bool isa(const Base* base) {
   66|    666|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    666|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    666|  return Derived::classof(base);
   68|    666|}
_ZN4wabt4castINS_10OpcodeExprILNS_8ExprTypeE7EEENS_4ExprEEEPT_PT0_:
   77|    737|Derived* cast(Base* base) {
   78|    737|  assert(isa<Derived>(base));
   79|    737|  return static_cast<Derived*>(base);
   80|    737|};
_ZN4wabt3isaINS_10OpcodeExprILNS_8ExprTypeE7EEENS_4ExprEEEbPKT0_:
   65|    737|bool isa(const Base* base) {
   66|    737|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    737|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    737|  return Derived::classof(base);
   68|    737|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE9EEENS_4ExprEEEPT_PT0_:
   77|  7.20k|Derived* cast(Base* base) {
   78|  7.20k|  assert(isa<Derived>(base));
   79|  7.20k|  return static_cast<Derived*>(base);
   80|  7.20k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE9EEENS_4ExprEEEbPKT0_:
   65|  7.20k|bool isa(const Base* base) {
   66|  7.20k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  7.20k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  7.20k|  return Derived::classof(base);
   68|  7.20k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE10EEENS_4ExprEEEPT_PT0_:
   77|    555|Derived* cast(Base* base) {
   78|    555|  assert(isa<Derived>(base));
   79|    555|  return static_cast<Derived*>(base);
   80|    555|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE10EEENS_4ExprEEEbPKT0_:
   65|    555|bool isa(const Base* base) {
   66|    555|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    555|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    555|  return Derived::classof(base);
   68|    555|}
_ZN4wabt4castINS_11BrTableExprENS_4ExprEEEPT_PT0_:
   77|  1.15k|Derived* cast(Base* base) {
   78|  1.15k|  assert(isa<Derived>(base));
   79|  1.15k|  return static_cast<Derived*>(base);
   80|  1.15k|};
_ZN4wabt3isaINS_11BrTableExprENS_4ExprEEEbPKT0_:
   65|  1.15k|bool isa(const Base* base) {
   66|  1.15k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.15k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.15k|  return Derived::classof(base);
   68|  1.15k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE12EEENS_4ExprEEEPT_PT0_:
   77|  4.42k|Derived* cast(Base* base) {
   78|  4.42k|  assert(isa<Derived>(base));
   79|  4.42k|  return static_cast<Derived*>(base);
   80|  4.42k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE12EEENS_4ExprEEEbPKT0_:
   65|  4.42k|bool isa(const Base* base) {
   66|  4.42k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  4.42k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  4.42k|  return Derived::classof(base);
   68|  4.42k|}
_ZN4wabt4castINS_16CallIndirectExprENS_4ExprEEEPT_PT0_:
   77|  4.50k|Derived* cast(Base* base) {
   78|  4.50k|  assert(isa<Derived>(base));
   79|  4.50k|  return static_cast<Derived*>(base);
   80|  4.50k|};
_ZN4wabt3isaINS_16CallIndirectExprENS_4ExprEEEbPKT0_:
   65|  4.50k|bool isa(const Base* base) {
   66|  4.50k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  4.50k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  4.50k|  return Derived::classof(base);
   68|  4.50k|}
_ZN4wabt4castINS_11CallRefExprENS_4ExprEEEPT_PT0_:
   77|    194|Derived* cast(Base* base) {
   78|    194|  assert(isa<Derived>(base));
   79|    194|  return static_cast<Derived*>(base);
   80|    194|};
_ZN4wabt3isaINS_11CallRefExprENS_4ExprEEEbPKT0_:
   65|    194|bool isa(const Base* base) {
   66|    194|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    194|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    194|  return Derived::classof(base);
   68|    194|}
_ZN4wabt4castINS_16CodeMetadataExprENS_4ExprEEEPT_PT0_:
   77|  1.74k|Derived* cast(Base* base) {
   78|  1.74k|  assert(isa<Derived>(base));
   79|  1.74k|  return static_cast<Derived*>(base);
   80|  1.74k|};
_ZN4wabt3isaINS_16CodeMetadataExprENS_4ExprEEEbPKT0_:
   65|  1.74k|bool isa(const Base* base) {
   66|  1.74k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.74k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.74k|  return Derived::classof(base);
   68|  1.74k|}
_ZN4wabt4castINS_10OpcodeExprILNS_8ExprTypeE16EEENS_4ExprEEEPT_PT0_:
   77|    644|Derived* cast(Base* base) {
   78|    644|  assert(isa<Derived>(base));
   79|    644|  return static_cast<Derived*>(base);
   80|    644|};
_ZN4wabt3isaINS_10OpcodeExprILNS_8ExprTypeE16EEENS_4ExprEEEbPKT0_:
   65|    644|bool isa(const Base* base) {
   66|    644|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    644|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    644|  return Derived::classof(base);
   68|    644|}
_ZN4wabt4castINS_9ConstExprENS_4ExprEEEPT_PT0_:
   77|  52.9k|Derived* cast(Base* base) {
   78|  52.9k|  assert(isa<Derived>(base));
   79|  52.9k|  return static_cast<Derived*>(base);
   80|  52.9k|};
_ZN4wabt3isaINS_9ConstExprENS_4ExprEEEbPKT0_:
   65|  52.9k|bool isa(const Base* base) {
   66|  52.9k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  52.9k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  52.9k|  return Derived::classof(base);
   68|  52.9k|}
_ZN4wabt4castINS_10OpcodeExprILNS_8ExprTypeE18EEENS_4ExprEEEPT_PT0_:
   77|    196|Derived* cast(Base* base) {
   78|    196|  assert(isa<Derived>(base));
   79|    196|  return static_cast<Derived*>(base);
   80|    196|};
_ZN4wabt3isaINS_10OpcodeExprILNS_8ExprTypeE18EEENS_4ExprEEEbPKT0_:
   65|    196|bool isa(const Base* base) {
   66|    196|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    196|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    196|  return Derived::classof(base);
   68|    196|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE19EEENS_4ExprEEEPT_PT0_:
   77|    312|Derived* cast(Base* base) {
   78|    312|  assert(isa<Derived>(base));
   79|    312|  return static_cast<Derived*>(base);
   80|    312|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE19EEENS_4ExprEEEbPKT0_:
   65|    312|bool isa(const Base* base) {
   66|    312|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    312|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    312|  return Derived::classof(base);
   68|    312|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE20EEENS_4ExprEEEPT_PT0_:
   77|  1.77k|Derived* cast(Base* base) {
   78|  1.77k|  assert(isa<Derived>(base));
   79|  1.77k|  return static_cast<Derived*>(base);
   80|  1.77k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE20EEENS_4ExprEEEbPKT0_:
   65|  1.77k|bool isa(const Base* base) {
   66|  1.77k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.77k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.77k|  return Derived::classof(base);
   68|  1.77k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE21EEENS_4ExprEEEPT_PT0_:
   77|  1.49k|Derived* cast(Base* base) {
   78|  1.49k|  assert(isa<Derived>(base));
   79|  1.49k|  return static_cast<Derived*>(base);
   80|  1.49k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE21EEENS_4ExprEEEbPKT0_:
   65|  1.49k|bool isa(const Base* base) {
   66|  1.49k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.49k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.49k|  return Derived::classof(base);
   68|  1.49k|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE23EEENS_4ExprEEEPT_PT0_:
   77|  1.22k|Derived* cast(Base* base) {
   78|  1.22k|  assert(isa<Derived>(base));
   79|  1.22k|  return static_cast<Derived*>(base);
   80|  1.22k|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE23EEENS_4ExprEEEbPKT0_:
   65|  1.22k|bool isa(const Base* base) {
   66|  1.22k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.22k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.22k|  return Derived::classof(base);
   68|  1.22k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE24EEENS_4ExprEEEPT_PT0_:
   77|  1.88k|Derived* cast(Base* base) {
   78|  1.88k|  assert(isa<Derived>(base));
   79|  1.88k|  return static_cast<Derived*>(base);
   80|  1.88k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE24EEENS_4ExprEEEbPKT0_:
   65|  1.88k|bool isa(const Base* base) {
   66|  1.88k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.88k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.88k|  return Derived::classof(base);
   68|  1.88k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE25EEENS_4ExprEEEPT_PT0_:
   77|  1.89k|Derived* cast(Base* base) {
   78|  1.89k|  assert(isa<Derived>(base));
   79|  1.89k|  return static_cast<Derived*>(base);
   80|  1.89k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE25EEENS_4ExprEEEbPKT0_:
   65|  1.89k|bool isa(const Base* base) {
   66|  1.89k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.89k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.89k|  return Derived::classof(base);
   68|  1.89k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE26EEENS_4ExprEEEPT_PT0_:
   77|  1.92k|Derived* cast(Base* base) {
   78|  1.92k|  assert(isa<Derived>(base));
   79|  1.92k|  return static_cast<Derived*>(base);
   80|  1.92k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE26EEENS_4ExprEEEbPKT0_:
   65|  1.92k|bool isa(const Base* base) {
   66|  1.92k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.92k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.92k|  return Derived::classof(base);
   68|  1.92k|}
_ZN4wabt4castINS_16MemoryBinaryExprILNS_8ExprTypeE28EEENS_4ExprEEEPT_PT0_:
   77|    534|Derived* cast(Base* base) {
   78|    534|  assert(isa<Derived>(base));
   79|    534|  return static_cast<Derived*>(base);
   80|    534|};
_ZN4wabt3isaINS_16MemoryBinaryExprILNS_8ExprTypeE28EEENS_4ExprEEEbPKT0_:
   65|    534|bool isa(const Base* base) {
   66|    534|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    534|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    534|  return Derived::classof(base);
   68|    534|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE29EEENS_4ExprEEEPT_PT0_:
   77|  1.89k|Derived* cast(Base* base) {
   78|  1.89k|  assert(isa<Derived>(base));
   79|  1.89k|  return static_cast<Derived*>(base);
   80|  1.89k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE29EEENS_4ExprEEEbPKT0_:
   65|  1.89k|bool isa(const Base* base) {
   66|  1.89k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.89k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.89k|  return Derived::classof(base);
   68|  1.89k|}
_ZN4wabt4castINS_10MemoryExprILNS_8ExprTypeE30EEENS_4ExprEEEPT_PT0_:
   77|    582|Derived* cast(Base* base) {
   78|    582|  assert(isa<Derived>(base));
   79|    582|  return static_cast<Derived*>(base);
   80|    582|};
_ZN4wabt3isaINS_10MemoryExprILNS_8ExprTypeE30EEENS_4ExprEEEbPKT0_:
   65|    582|bool isa(const Base* base) {
   66|    582|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    582|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    582|  return Derived::classof(base);
   68|    582|}
_ZN4wabt4castINS_10MemoryExprILNS_8ExprTypeE31EEENS_4ExprEEEPT_PT0_:
   77|    520|Derived* cast(Base* base) {
   78|    520|  assert(isa<Derived>(base));
   79|    520|  return static_cast<Derived*>(base);
   80|    520|};
_ZN4wabt3isaINS_10MemoryExprILNS_8ExprTypeE31EEENS_4ExprEEEbPKT0_:
   65|    520|bool isa(const Base* base) {
   66|    520|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    520|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    520|  return Derived::classof(base);
   68|    520|}
_ZN4wabt4castINS_13MemoryVarExprILNS_8ExprTypeE32EEENS_4ExprEEEPT_PT0_:
   77|  1.72k|Derived* cast(Base* base) {
   78|  1.72k|  assert(isa<Derived>(base));
   79|  1.72k|  return static_cast<Derived*>(base);
   80|  1.72k|};
_ZN4wabt3isaINS_13MemoryVarExprILNS_8ExprTypeE32EEENS_4ExprEEEbPKT0_:
   65|  1.72k|bool isa(const Base* base) {
   66|  1.72k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.72k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.72k|  return Derived::classof(base);
   68|  1.72k|}
_ZN4wabt4castINS_10MemoryExprILNS_8ExprTypeE33EEENS_4ExprEEEPT_PT0_:
   77|  3.06k|Derived* cast(Base* base) {
   78|  3.06k|  assert(isa<Derived>(base));
   79|  3.06k|  return static_cast<Derived*>(base);
   80|  3.06k|};
_ZN4wabt3isaINS_10MemoryExprILNS_8ExprTypeE33EEENS_4ExprEEEbPKT0_:
   65|  3.06k|bool isa(const Base* base) {
   66|  3.06k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  3.06k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  3.06k|  return Derived::classof(base);
   68|  3.06k|}
_ZN4wabt4castINS_13TableCopyExprENS_4ExprEEEPT_PT0_:
   77|  4.67k|Derived* cast(Base* base) {
   78|  4.67k|  assert(isa<Derived>(base));
   79|  4.67k|  return static_cast<Derived*>(base);
   80|  4.67k|};
_ZN4wabt3isaINS_13TableCopyExprENS_4ExprEEEbPKT0_:
   65|  4.67k|bool isa(const Base* base) {
   66|  4.67k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  4.67k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  4.67k|  return Derived::classof(base);
   68|  4.67k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE51EEENS_4ExprEEEPT_PT0_:
   77|  2.41k|Derived* cast(Base* base) {
   78|  2.41k|  assert(isa<Derived>(base));
   79|  2.41k|  return static_cast<Derived*>(base);
   80|  2.41k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE51EEENS_4ExprEEEbPKT0_:
   65|  2.41k|bool isa(const Base* base) {
   66|  2.41k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  2.41k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  2.41k|  return Derived::classof(base);
   68|  2.41k|}
_ZN4wabt4castINS_13TableInitExprENS_4ExprEEEPT_PT0_:
   77|  7.90k|Derived* cast(Base* base) {
   78|  7.90k|  assert(isa<Derived>(base));
   79|  7.90k|  return static_cast<Derived*>(base);
   80|  7.90k|};
_ZN4wabt3isaINS_13TableInitExprENS_4ExprEEEbPKT0_:
   65|  7.90k|bool isa(const Base* base) {
   66|  7.90k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  7.90k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  7.90k|  return Derived::classof(base);
   68|  7.90k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE53EEENS_4ExprEEEPT_PT0_:
   77|  1.76k|Derived* cast(Base* base) {
   78|  1.76k|  assert(isa<Derived>(base));
   79|  1.76k|  return static_cast<Derived*>(base);
   80|  1.76k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE53EEENS_4ExprEEEbPKT0_:
   65|  1.76k|bool isa(const Base* base) {
   66|  1.76k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.76k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.76k|  return Derived::classof(base);
   68|  1.76k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE56EEENS_4ExprEEEPT_PT0_:
   77|  2.44k|Derived* cast(Base* base) {
   78|  2.44k|  assert(isa<Derived>(base));
   79|  2.44k|  return static_cast<Derived*>(base);
   80|  2.44k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE56EEENS_4ExprEEEbPKT0_:
   65|  2.44k|bool isa(const Base* base) {
   66|  2.44k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  2.44k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  2.44k|  return Derived::classof(base);
   68|  2.44k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE54EEENS_4ExprEEEPT_PT0_:
   77|  1.82k|Derived* cast(Base* base) {
   78|  1.82k|  assert(isa<Derived>(base));
   79|  1.82k|  return static_cast<Derived*>(base);
   80|  1.82k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE54EEENS_4ExprEEEbPKT0_:
   65|  1.82k|bool isa(const Base* base) {
   66|  1.82k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.82k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.82k|  return Derived::classof(base);
   68|  1.82k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE55EEENS_4ExprEEEPT_PT0_:
   77|  2.46k|Derived* cast(Base* base) {
   78|  2.46k|  assert(isa<Derived>(base));
   79|  2.46k|  return static_cast<Derived*>(base);
   80|  2.46k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE55EEENS_4ExprEEEbPKT0_:
   65|  2.46k|bool isa(const Base* base) {
   66|  2.46k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  2.46k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  2.46k|  return Derived::classof(base);
   68|  2.46k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE57EEENS_4ExprEEEPT_PT0_:
   77|  2.21k|Derived* cast(Base* base) {
   78|  2.21k|  assert(isa<Derived>(base));
   79|  2.21k|  return static_cast<Derived*>(base);
   80|  2.21k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE57EEENS_4ExprEEEbPKT0_:
   65|  2.21k|bool isa(const Base* base) {
   66|  2.21k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  2.21k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  2.21k|  return Derived::classof(base);
   68|  2.21k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE36EEENS_4ExprEEEPT_PT0_:
   77|   135k|Derived* cast(Base* base) {
   78|   135k|  assert(isa<Derived>(base));
   79|   135k|  return static_cast<Derived*>(base);
   80|   135k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE36EEENS_4ExprEEEbPKT0_:
   65|   135k|bool isa(const Base* base) {
   66|   135k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   135k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   135k|  return Derived::classof(base);
   68|   135k|}
_ZN4wabt4castINS_11RefTypeExprILNS_8ExprTypeE37EEENS_4ExprEEEPT_PT0_:
   77|    194|Derived* cast(Base* base) {
   78|    194|  assert(isa<Derived>(base));
   79|    194|  return static_cast<Derived*>(base);
   80|    194|};
_ZN4wabt3isaINS_11RefTypeExprILNS_8ExprTypeE37EEENS_4ExprEEEbPKT0_:
   65|    194|bool isa(const Base* base) {
   66|    194|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    194|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    194|  return Derived::classof(base);
   68|    194|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE35EEENS_4ExprEEEPT_PT0_:
   77|    706|Derived* cast(Base* base) {
   78|    706|  assert(isa<Derived>(base));
   79|    706|  return static_cast<Derived*>(base);
   80|    706|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE35EEENS_4ExprEEEbPKT0_:
   65|    706|bool isa(const Base* base) {
   66|    706|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    706|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    706|  return Derived::classof(base);
   68|    706|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE34EEENS_4ExprEEEPT_PT0_:
   77|   125k|Derived* cast(Base* base) {
   78|   125k|  assert(isa<Derived>(base));
   79|   125k|  return static_cast<Derived*>(base);
   80|   125k|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE34EEENS_4ExprEEEbPKT0_:
   65|   125k|bool isa(const Base* base) {
   66|   125k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|   125k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|   125k|  return Derived::classof(base);
   68|   125k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE38EEENS_4ExprEEEPT_PT0_:
   77|    520|Derived* cast(Base* base) {
   78|    520|  assert(isa<Derived>(base));
   79|    520|  return static_cast<Derived*>(base);
   80|    520|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE38EEENS_4ExprEEEbPKT0_:
   65|    520|bool isa(const Base* base) {
   66|    520|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    520|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    520|  return Derived::classof(base);
   68|    520|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE39EEENS_4ExprEEEPT_PT0_:
   77|  1.05k|Derived* cast(Base* base) {
   78|  1.05k|  assert(isa<Derived>(base));
   79|  1.05k|  return static_cast<Derived*>(base);
   80|  1.05k|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE39EEENS_4ExprEEEbPKT0_:
   65|  1.05k|bool isa(const Base* base) {
   66|  1.05k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.05k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.05k|  return Derived::classof(base);
   68|  1.05k|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE40EEENS_4ExprEEEPT_PT0_:
   77|  1.71k|Derived* cast(Base* base) {
   78|  1.71k|  assert(isa<Derived>(base));
   79|  1.71k|  return static_cast<Derived*>(base);
   80|  1.71k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE40EEENS_4ExprEEEbPKT0_:
   65|  1.71k|bool isa(const Base* base) {
   66|  1.71k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.71k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.71k|  return Derived::classof(base);
   68|  1.71k|}
_ZN4wabt4castINS_22ReturnCallIndirectExprENS_4ExprEEEPT_PT0_:
   77|  4.50k|Derived* cast(Base* base) {
   78|  4.50k|  assert(isa<Derived>(base));
   79|  4.50k|  return static_cast<Derived*>(base);
   80|  4.50k|};
_ZN4wabt3isaINS_22ReturnCallIndirectExprENS_4ExprEEEbPKT0_:
   65|  4.50k|bool isa(const Base* base) {
   66|  4.50k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  4.50k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  4.50k|  return Derived::classof(base);
   68|  4.50k|}
_ZN4wabt4castINS_10SelectExprENS_4ExprEEEPT_PT0_:
   77|    208|Derived* cast(Base* base) {
   78|    208|  assert(isa<Derived>(base));
   79|    208|  return static_cast<Derived*>(base);
   80|    208|};
_ZN4wabt3isaINS_10SelectExprENS_4ExprEEEbPKT0_:
   65|    208|bool isa(const Base* base) {
   66|    208|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    208|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    208|  return Derived::classof(base);
   68|    208|}
_ZN4wabt4castINS_13LoadStoreExprILNS_8ExprTypeE49EEENS_4ExprEEEPT_PT0_:
   77|    686|Derived* cast(Base* base) {
   78|    686|  assert(isa<Derived>(base));
   79|    686|  return static_cast<Derived*>(base);
   80|    686|};
_ZN4wabt3isaINS_13LoadStoreExprILNS_8ExprTypeE49EEENS_4ExprEEEbPKT0_:
   65|    686|bool isa(const Base* base) {
   66|    686|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    686|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    686|  return Derived::classof(base);
   68|    686|}
_ZN4wabt4castINS_7VarExprILNS_8ExprTypeE59EEENS_4ExprEEEPT_PT0_:
   77|  3.60k|Derived* cast(Base* base) {
   78|  3.60k|  assert(isa<Derived>(base));
   79|  3.60k|  return static_cast<Derived*>(base);
   80|  3.60k|};
_ZN4wabt3isaINS_7VarExprILNS_8ExprTypeE59EEENS_4ExprEEEbPKT0_:
   65|  3.60k|bool isa(const Base* base) {
   66|  3.60k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  3.60k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  3.60k|  return Derived::classof(base);
   68|  3.60k|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE60EEENS_4ExprEEEPT_PT0_:
   77|    458|Derived* cast(Base* base) {
   78|    458|  assert(isa<Derived>(base));
   79|    458|  return static_cast<Derived*>(base);
   80|    458|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE60EEENS_4ExprEEEbPKT0_:
   65|    458|bool isa(const Base* base) {
   66|    458|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    458|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    458|  return Derived::classof(base);
   68|    458|}
_ZN4wabt4castINS_10OpcodeExprILNS_8ExprTypeE63EEENS_4ExprEEEPT_PT0_:
   77|  1.20k|Derived* cast(Base* base) {
   78|  1.20k|  assert(isa<Derived>(base));
   79|  1.20k|  return static_cast<Derived*>(base);
   80|  1.20k|};
_ZN4wabt3isaINS_10OpcodeExprILNS_8ExprTypeE63EEENS_4ExprEEEbPKT0_:
   65|  1.20k|bool isa(const Base* base) {
   66|  1.20k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  1.20k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  1.20k|  return Derived::classof(base);
   68|  1.20k|}
_ZN4wabt4castINS_10OpcodeExprILNS_8ExprTypeE58EEENS_4ExprEEEPT_PT0_:
   77|    658|Derived* cast(Base* base) {
   78|    658|  assert(isa<Derived>(base));
   79|    658|  return static_cast<Derived*>(base);
   80|    658|};
_ZN4wabt3isaINS_10OpcodeExprILNS_8ExprTypeE58EEENS_4ExprEEEbPKT0_:
   65|    658|bool isa(const Base* base) {
   66|    658|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    658|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    658|  return Derived::classof(base);
   68|    658|}
_ZN4wabt4castINS_14SimdLaneOpExprENS_4ExprEEEPT_PT0_:
   77|    208|Derived* cast(Base* base) {
   78|    208|  assert(isa<Derived>(base));
   79|    208|  return static_cast<Derived*>(base);
   80|    208|};
_ZN4wabt3isaINS_14SimdLaneOpExprENS_4ExprEEEbPKT0_:
   65|    208|bool isa(const Base* base) {
   66|    208|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    208|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    208|  return Derived::classof(base);
   68|    208|}
_ZN4wabt4castINS_16SimdLoadLaneExprENS_4ExprEEEPT_PT0_:
   77|    520|Derived* cast(Base* base) {
   78|    520|  assert(isa<Derived>(base));
   79|    520|  return static_cast<Derived*>(base);
   80|    520|};
_ZN4wabt3isaINS_16SimdLoadLaneExprENS_4ExprEEEbPKT0_:
   65|    520|bool isa(const Base* base) {
   66|    520|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    520|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    520|  return Derived::classof(base);
   68|    520|}
_ZN4wabt4castINS_17SimdStoreLaneExprENS_4ExprEEEPT_PT0_:
   77|    754|Derived* cast(Base* base) {
   78|    754|  assert(isa<Derived>(base));
   79|    754|  return static_cast<Derived*>(base);
   80|    754|};
_ZN4wabt3isaINS_17SimdStoreLaneExprENS_4ExprEEEbPKT0_:
   65|    754|bool isa(const Base* base) {
   66|    754|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    754|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    754|  return Derived::classof(base);
   68|    754|}
_ZN4wabt4castINS_17SimdShuffleOpExprENS_4ExprEEEPT_PT0_:
   77|    454|Derived* cast(Base* base) {
   78|    454|  assert(isa<Derived>(base));
   79|    454|  return static_cast<Derived*>(base);
   80|    454|};
_ZN4wabt3isaINS_17SimdShuffleOpExprENS_4ExprEEEbPKT0_:
   65|    454|bool isa(const Base* base) {
   66|    454|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    454|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    454|  return Derived::classof(base);
   68|    454|}
_ZN4wabt4castINS_9ExprMixinILNS_8ExprTypeE64EEENS_4ExprEEEPT_PT0_:
   77|    258|Derived* cast(Base* base) {
   78|    258|  assert(isa<Derived>(base));
   79|    258|  return static_cast<Derived*>(base);
   80|    258|};
_ZN4wabt3isaINS_9ExprMixinILNS_8ExprTypeE64EEENS_4ExprEEEbPKT0_:
   65|    258|bool isa(const Base* base) {
   66|    258|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    258|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    258|  return Derived::classof(base);
   68|    258|}
_ZN4wabt8dyn_castINS_8FuncTypeENS_9TypeEntryEEEPT_PT0_:
   88|  2.29M|Derived* dyn_cast(Base* base) {
   89|  2.29M|  return isa<Derived>(base) ? static_cast<Derived*>(base) : nullptr;
  ------------------
  |  Branch (89:10): [True: 2.26M, False: 22.2k]
  ------------------
   90|  2.29M|};
_ZN4wabt3isaINS_8FuncTypeENS_9TypeEntryEEEbPKT0_:
   65|  2.29M|bool isa(const Base* base) {
   66|  2.29M|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  2.29M|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  2.29M|  return Derived::classof(base);
   68|  2.29M|}
_ZN4wabt4castINS_10FuncImportENS_6ImportEEEPT_PT0_:
   77|  73.5k|Derived* cast(Base* base) {
   78|  73.5k|  assert(isa<Derived>(base));
   79|  73.5k|  return static_cast<Derived*>(base);
   80|  73.5k|};
_ZN4wabt4castINS_11TableImportENS_6ImportEEEPT_PT0_:
   77|  17.2k|Derived* cast(Base* base) {
   78|  17.2k|  assert(isa<Derived>(base));
   79|  17.2k|  return static_cast<Derived*>(base);
   80|  17.2k|};
_ZN4wabt3isaINS_11TableImportENS_6ImportEEEbPKT0_:
   65|  17.2k|bool isa(const Base* base) {
   66|  17.2k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  17.2k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  17.2k|  return Derived::classof(base);
   68|  17.2k|}
_ZN4wabt4castINS_12MemoryImportENS_6ImportEEEPT_PT0_:
   77|    698|Derived* cast(Base* base) {
   78|    698|  assert(isa<Derived>(base));
   79|    698|  return static_cast<Derived*>(base);
   80|    698|};
_ZN4wabt3isaINS_12MemoryImportENS_6ImportEEEbPKT0_:
   65|    698|bool isa(const Base* base) {
   66|    698|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|    698|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|    698|  return Derived::classof(base);
   68|    698|}
_ZN4wabt4castINS_12GlobalImportENS_6ImportEEEPT_PT0_:
   77|  26.3k|Derived* cast(Base* base) {
   78|  26.3k|  assert(isa<Derived>(base));
   79|  26.3k|  return static_cast<Derived*>(base);
   80|  26.3k|};
_ZN4wabt3isaINS_12GlobalImportENS_6ImportEEEbPKT0_:
   65|  26.3k|bool isa(const Base* base) {
   66|  26.3k|  WABT_STATIC_ASSERT((std::is_base_of<Base, Derived>::value));
  ------------------
  |  |   89|  26.3k|#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
  ------------------
   67|  26.3k|  return Derived::classof(base);
   68|  26.3k|}
_ZN4wabt4castINS_9TagImportENS_6ImportEEEPT_PT0_:
   77|  63.9k|Derived* cast(Base* base) {
   78|  63.9k|  assert(isa<Derived>(base));
   79|  63.9k|  return static_cast<Derived*>(base);
   80|  63.9k|};
_ZN4wabt4castINS_17ExportModuleFieldENS_11ModuleFieldEEENSt3__110unique_ptrIT_NS3_14default_deleteIS5_EEEEONS4_IT0_NS6_IS9_EEEE:
  102|  42.4k|std::unique_ptr<Derived> cast(std::unique_ptr<Base>&& base) {
  103|  42.4k|  assert(isa<Derived>(base.get()));
  104|  42.4k|  return std::unique_ptr<Derived>(static_cast<Derived*>(base.release()));
  105|  42.4k|};

_Z23WABT_BYTES_TO_MIN_PAGESmj:
   50|    563|                                        uint32_t page_size) {
   51|    563|  if ((page_size == 0) ||
  ------------------
  |  Branch (51:7): [True: 0, False: 563]
  ------------------
   52|    563|      (page_size & (page_size - 1))) {  // malformed page sizes
  ------------------
  |  Branch (52:7): [True: 0, False: 563]
  ------------------
   53|      0|    WABT_UNREACHABLE;
  ------------------
  |  |  112|      0|#define WABT_UNREACHABLE abort()
  ------------------
   54|      0|    return 0;
   55|      0|  }
   56|    563|  uint64_t num_pages = num_bytes / page_size;
   57|    563|  return (page_size * num_pages == num_bytes) ? num_pages : num_pages + 1;
  ------------------
  |  Branch (57:10): [True: 369, False: 194]
  ------------------
   58|    563|}
_ZN4wabt17MemcpyEndianAwareEPvPKvmmmmm:
   95|   969k|                              size_t len) {
   96|       |#if WABT_BIG_ENDIAN
   97|       |  memcpy(static_cast<char*>(dst) + (dsize) - (len) - (doff),
   98|       |         static_cast<const char*>(src) + (ssize) - (len) - (soff), (len));
   99|       |#else
  100|   969k|  memcpy(static_cast<char*>(dst) + (doff),
  101|   969k|         static_cast<const char*>(src) + (soff), (len));
  102|   969k|#endif
  103|   969k|}
_ZNK4v1288f32_bitsEi:
  124|  7.20k|  uint32_t f32_bits(int lane) const { return To<uint32_t>(lane); }
_ZNK4v1288f64_bitsEi:
  125|  93.1k|  uint64_t f64_bits(int lane) const { return To<uint64_t>(lane); }
_ZN4v1286set_u8Eih:
  127|  6.02k|  void set_u8(int lane, uint8_t x) { return From<uint8_t>(lane, x); }
_ZN4wabt8LocationC2Ev:
  211|  10.0M|  Location() : line(0), first_column(0), last_column(0) {}
_ZN4wabt8LocationC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEiii:
  216|  48.6M|      : filename(filename),
  217|  48.6M|        line(line),
  218|  48.6M|        first_column(first_column),
  219|  48.6M|        last_column(last_column) {}
_ZNK4v1282ToIjEET_i:
  141|  7.20k|  T To(int lane) const {
  142|  7.20k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  143|  7.20k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  144|  7.20k|    T result;
  145|  7.20k|    wabt::MemcpyEndianAware(&result, v, sizeof(result), sizeof(v), 0,
  146|  7.20k|                            lane * sizeof(T), sizeof(result));
  147|  7.20k|    return result;
  148|  7.20k|  }
_ZNK4v1282ToImEET_i:
  141|  93.1k|  T To(int lane) const {
  142|  93.1k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  143|  93.1k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  144|  93.1k|    T result;
  145|  93.1k|    wabt::MemcpyEndianAware(&result, v, sizeof(result), sizeof(v), 0,
  146|  93.1k|                            lane * sizeof(T), sizeof(result));
  147|  93.1k|    return result;
  148|  93.1k|  }
_ZN4v1284FromIhEEviT_:
  151|  8.54k|  void From(int lane, T data) {
  152|  8.54k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  153|  8.54k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  154|  8.54k|    wabt::MemcpyEndianAware(v, &data, sizeof(v), sizeof(data), lane * sizeof(T),
  155|  8.54k|                            0, sizeof(data));
  156|  8.54k|  }
_ZN4v1284FromItEEviT_:
  151|  4.40k|  void From(int lane, T data) {
  152|  4.40k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  153|  4.40k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  154|  4.40k|    wabt::MemcpyEndianAware(v, &data, sizeof(v), sizeof(data), lane * sizeof(T),
  155|  4.40k|                            0, sizeof(data));
  156|  4.40k|  }
_ZN4v1284FromIjEEviT_:
  151|   577k|  void From(int lane, T data) {
  152|   577k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  153|   577k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  154|   577k|    wabt::MemcpyEndianAware(v, &data, sizeof(v), sizeof(data), lane * sizeof(T),
  155|   577k|                            0, sizeof(data));
  156|   577k|  }
_ZN4v1284FromImEEviT_:
  151|   278k|  void From(int lane, T data) {
  152|   278k|    static_assert(sizeof(T) <= sizeof(v), "Invalid cast!");
  153|   278k|    assert((lane + 1) * sizeof(T) <= sizeof(v));
  154|   278k|    wabt::MemcpyEndianAware(v, &data, sizeof(v), sizeof(data), lane * sizeof(T),
  155|   278k|                            0, sizeof(data));
  156|   278k|  }
_ZN4wabt6LimitsC2Ev:
  380|   729k|  Limits() = default;
_ZN4wabt9ConstructINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEJS7_EEEvRT_DpOT0_:
  179|  2.97M|void Construct(T& placement, Args&&... args) {
  180|  2.97M|  new (&placement) T(std::forward<Args>(args)...);
  181|  2.97M|}
_ZN4wabt8DestructINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_:
  185|  3.86M|void Destruct(T& placement) {
  186|  3.86M|  placement.~T();
  187|  3.86M|}
_ZN4wabt9ConstructINS_4TypeEJRS1_EEEvRT_DpOT0_:
  179|  2.91M|void Construct(T& placement, Args&&... args) {
  180|  2.91M|  new (&placement) T(std::forward<Args>(args)...);
  181|  2.91M|}
_ZN4wabt9ConstructINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEJRS5_EEEvRT_DpOT0_:
  179|  7.70M|void Construct(T& placement, Args&&... args) {
  180|  7.70M|  new (&placement) T(std::forward<Args>(args)...);
  181|  7.70M|}
_ZN4wabt9ConstructINS_6OpcodeEJRS1_EEEvRT_DpOT0_:
  179|  1.24M|void Construct(T& placement, Args&&... args) {
  180|  1.24M|  new (&placement) T(std::forward<Args>(args)...);
  181|  1.24M|}
_ZN4wabt9ConstructINS_7LiteralEJRKS1_EEEvRT_DpOT0_:
  179|  1.54M|void Construct(T& placement, Args&&... args) {
  180|  1.54M|  new (&placement) T(std::forward<Args>(args)...);
  181|  1.54M|}

_ZN4wabt5ErrorC2ENS_10ErrorLevelENS_8LocationENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   47|  28.9M|      : error_level(error_level), loc(loc), message(message) {}

_ZN4wabt11ExprVisitor8DelegateD2Ev:
   69|   994k|  virtual ~Delegate() {}
_ZN4wabt11ExprVisitor11DelegateNop12OnBinaryExprEPNS_10OpcodeExprILNS_8ExprTypeE7EEE:
  148|    737|  Result OnBinaryExpr(BinaryExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop12EndBlockExprEPNS_13BlockExprBaseILNS_8ExprTypeE8EEE:
  150|  3.80k|  Result EndBlockExpr(BlockExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop8OnBrExprEPNS_7VarExprILNS_8ExprTypeE9EEE:
  151|  3.71k|  Result OnBrExpr(BrExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop10OnBrIfExprEPNS_7VarExprILNS_8ExprTypeE10EEE:
  152|    275|  Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnBrTableExprEPNS_11BrTableExprE:
  153|    577|  Result OnBrTableExpr(BrTableExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop17BeginTryTableExprEPNS_12TryTableExprE:
  154|  1.58k|  Result BeginTryTableExpr(TryTableExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15EndTryTableExprEPNS_12TryTableExprE:
  155|  1.58k|  Result EndTryTableExpr(TryTableExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop10OnCallExprEPNS_7VarExprILNS_8ExprTypeE12EEE:
  156|  2.21k|  Result OnCallExpr(CallExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnCallRefExprEPNS_11CallRefExprE:
  158|    194|  Result OnCallRefExpr(CallRefExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop18OnCodeMetadataExprEPNS_16CodeMetadataExprE:
  159|  1.74k|  Result OnCodeMetadataExpr(CodeMetadataExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnCompareExprEPNS_10OpcodeExprILNS_8ExprTypeE16EEE:
  160|    644|  Result OnCompareExpr(CompareExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11OnConstExprEPNS_9ConstExprE:
  161|  52.9k|  Result OnConstExpr(ConstExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnConvertExprEPNS_10OpcodeExprILNS_8ExprTypeE18EEE:
  162|    196|  Result OnConvertExpr(ConvertExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop10OnDropExprEPNS_9ExprMixinILNS_8ExprTypeE19EEE:
  163|    312|  Result OnDropExpr(DropExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnGlobalGetExprEPNS_7VarExprILNS_8ExprTypeE20EEE:
  164|    879|  Result OnGlobalGetExpr(GlobalGetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnGlobalSetExprEPNS_7VarExprILNS_8ExprTypeE21EEE:
  165|    647|  Result OnGlobalSetExpr(GlobalSetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15AfterIfTrueExprEPNS_6IfExprE:
  167|  3.66k|  Result AfterIfTrueExpr(IfExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop9EndIfExprEPNS_6IfExprE:
  168|  1.82k|  Result EndIfExpr(IfExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop10OnLoadExprEPNS_13LoadStoreExprILNS_8ExprTypeE23EEE:
  169|    615|  Result OnLoadExpr(LoadExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnLocalGetExprEPNS_7VarExprILNS_8ExprTypeE24EEE:
  170|    845|  Result OnLocalGetExpr(LocalGetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnLocalSetExprEPNS_7VarExprILNS_8ExprTypeE25EEE:
  171|    852|  Result OnLocalSetExpr(LocalSetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnLocalTeeExprEPNS_7VarExprILNS_8ExprTypeE26EEE:
  172|    866|  Result OnLocalTeeExpr(LocalTeeExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11EndLoopExprEPNS_13BlockExprBaseILNS_8ExprTypeE27EEE:
  174|  8.68k|  Result EndLoopExpr(LoopExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnMemoryCopyExprEPNS_16MemoryBinaryExprILNS_8ExprTypeE28EEE:
  175|    265|  Result OnMemoryCopyExpr(MemoryCopyExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnDataDropExprEPNS_7VarExprILNS_8ExprTypeE29EEE:
  176|    947|  Result OnDataDropExpr(DataDropExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnMemoryFillExprEPNS_10MemoryExprILNS_8ExprTypeE30EEE:
  177|    289|  Result OnMemoryFillExpr(MemoryFillExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnMemoryGrowExprEPNS_10MemoryExprILNS_8ExprTypeE31EEE:
  178|    258|  Result OnMemoryGrowExpr(MemoryGrowExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnMemoryInitExprEPNS_13MemoryVarExprILNS_8ExprTypeE32EEE:
  179|    861|  Result OnMemoryInitExpr(MemoryInitExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnMemorySizeExprEPNS_10MemoryExprILNS_8ExprTypeE33EEE:
  180|  1.53k|  Result OnMemorySizeExpr(MemorySizeExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnTableCopyExprEPNS_13TableCopyExprE:
  181|  2.33k|  Result OnTableCopyExpr(TableCopyExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnElemDropExprEPNS_7VarExprILNS_8ExprTypeE51EEE:
  182|  1.20k|  Result OnElemDropExpr(ElemDropExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnTableInitExprEPNS_13TableInitExprE:
  183|  3.94k|  Result OnTableInitExpr(TableInitExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnTableGetExprEPNS_7VarExprILNS_8ExprTypeE53EEE:
  184|    883|  Result OnTableGetExpr(TableGetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnTableSetExprEPNS_7VarExprILNS_8ExprTypeE56EEE:
  185|  1.22k|  Result OnTableSetExpr(TableSetExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnTableGrowExprEPNS_7VarExprILNS_8ExprTypeE54EEE:
  186|    911|  Result OnTableGrowExpr(TableGrowExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnTableSizeExprEPNS_7VarExprILNS_8ExprTypeE55EEE:
  187|  1.23k|  Result OnTableSizeExpr(TableSizeExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnTableFillExprEPNS_7VarExprILNS_8ExprTypeE57EEE:
  188|  1.10k|  Result OnTableFillExpr(TableFillExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnRefFuncExprEPNS_7VarExprILNS_8ExprTypeE36EEE:
  189|    881|  Result OnRefFuncExpr(RefFuncExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnRefNullExprEPNS_11RefTypeExprILNS_8ExprTypeE37EEE:
  190|    194|  Result OnRefNullExpr(RefNullExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnRefIsNullExprEPNS_9ExprMixinILNS_8ExprTypeE35EEE:
  191|    706|  Result OnRefIsNullExpr(RefIsNullExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop9OnNopExprEPNS_9ExprMixinILNS_8ExprTypeE34EEE:
  192|   125k|  Result OnNopExpr(NopExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop12OnReturnExprEPNS_9ExprMixinILNS_8ExprTypeE39EEE:
  193|  1.05k|  Result OnReturnExpr(ReturnExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnReturnCallExprEPNS_7VarExprILNS_8ExprTypeE40EEE:
  194|    854|  Result OnReturnCallExpr(ReturnCallExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop12OnSelectExprEPNS_10SelectExprE:
  198|    208|  Result OnSelectExpr(SelectExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11OnStoreExprEPNS_13LoadStoreExprILNS_8ExprTypeE49EEE:
  199|    342|  Result OnStoreExpr(StoreExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11OnUnaryExprEPNS_10OpcodeExprILNS_8ExprTypeE63EEE:
  200|  1.20k|  Result OnUnaryExpr(UnaryExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop17OnUnreachableExprEPNS_9ExprMixinILNS_8ExprTypeE64EEE:
  201|    258|  Result OnUnreachableExpr(UnreachableExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11OnCatchExprEPNS_7TryExprEPNS_5CatchE:
  203|  10.4k|  Result OnCatchExpr(TryExpr*, Catch*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop10EndTryExprEPNS_7TryExprE:
  205|  28.1k|  Result EndTryExpr(TryExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop11OnThrowExprEPNS_7VarExprILNS_8ExprTypeE59EEE:
  206|  1.79k|  Result OnThrowExpr(ThrowExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop14OnThrowRefExprEPNS_9ExprMixinILNS_8ExprTypeE60EEE:
  207|    458|  Result OnThrowRefExpr(ThrowRefExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop13OnRethrowExprEPNS_7VarExprILNS_8ExprTypeE38EEE:
  208|    259|  Result OnRethrowExpr(RethrowExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnAtomicWaitExprEPNS_13LoadStoreExprILNS_8ExprTypeE6EEE:
  209|    514|  Result OnAtomicWaitExpr(AtomicWaitExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop17OnAtomicFenceExprEPNS_15AtomicFenceExprE:
  210|    746|  Result OnAtomicFenceExpr(AtomicFenceExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop18OnAtomicNotifyExprEPNS_13LoadStoreExprILNS_8ExprTypeE4EEE:
  211|    666|  Result OnAtomicNotifyExpr(AtomicNotifyExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnAtomicLoadExprEPNS_13LoadStoreExprILNS_8ExprTypeE0EEE:
  212|    564|  Result OnAtomicLoadExpr(AtomicLoadExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop17OnAtomicStoreExprEPNS_13LoadStoreExprILNS_8ExprTypeE3EEE:
  213|  1.12k|  Result OnAtomicStoreExpr(AtomicStoreExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop15OnAtomicRmwExprEPNS_13LoadStoreExprILNS_8ExprTypeE1EEE:
  214|  1.70k|  Result OnAtomicRmwExpr(AtomicRmwExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop22OnAtomicRmwCmpxchgExprEPNS_13LoadStoreExprILNS_8ExprTypeE2EEE:
  215|    197|  Result OnAtomicRmwCmpxchgExpr(AtomicRmwCmpxchgExpr*) override {
  216|    197|    return Result::Ok;
  217|    197|  }
_ZN4wabt11ExprVisitor11DelegateNop13OnTernaryExprEPNS_10OpcodeExprILNS_8ExprTypeE58EEE:
  218|    658|  Result OnTernaryExpr(TernaryExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop16OnSimdLaneOpExprEPNS_14SimdLaneOpExprE:
  219|    208|  Result OnSimdLaneOpExpr(SimdLaneOpExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop18OnSimdLoadLaneExprEPNS_16SimdLoadLaneExprE:
  220|    258|  Result OnSimdLoadLaneExpr(SimdLoadLaneExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop19OnSimdStoreLaneExprEPNS_17SimdStoreLaneExprE:
  221|    376|  Result OnSimdStoreLaneExpr(SimdStoreLaneExpr*) override { return Result::Ok; }
_ZN4wabt11ExprVisitor11DelegateNop19OnSimdShuffleOpExprEPNS_17SimdShuffleOpExprE:
  222|    454|  Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) override { return Result::Ok; }

_ZNK4wabt8Features18exceptions_enabledEv:
   37|   748k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features24sat_float_to_int_enabledEv:
   37|  1.60k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features22sign_extension_enabledEv:
   37|  5.55k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features12simd_enabledEv:
   37|   108k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features15threads_enabledEv:
   37|  48.1k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features27function_references_enabledEv:
   37|   604k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features17tail_call_enabledEv:
   37|  5.02k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features19bulk_memory_enabledEv:
   37|   873k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features23reference_types_enabledEv:
   37|   275k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features19annotations_enabledEv:
   37|  4.86M|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features10gc_enabledEv:
   37|  3.13k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features16memory64_enabledEv:
   37|  8.67k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features20multi_memory_enabledEv:
   37|  19.6k|  bool variable##_enabled() const { return variable##_enabled_; } \
_ZNK4wabt8Features20relaxed_simd_enabledEv:
   37|  6.16k|  bool variable##_enabled() const { return variable##_enabled_; } \

_ZN4wabt14intrusive_listINS_11ModuleFieldEED2Ev:
  287|  3.08M|inline intrusive_list<T>::~intrusive_list() {
  288|  3.08M|  clear();
  289|  3.08M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE5clearEv:
  593|  3.08M|inline void intrusive_list<T>::clear() noexcept {
  594|  6.34M|  for (T* iter = first_; iter;) {
  ------------------
  |  Branch (594:26): [True: 3.26M, False: 3.08M]
  ------------------
  595|  3.26M|    T* next = iter->next_;
  596|  3.26M|    delete iter;
  597|  3.26M|    iter = next;
  598|  3.26M|  }
  599|  3.08M|  first_ = last_ = nullptr;
  600|  3.08M|  size_ = 0;
  601|  3.08M|}
_ZN4wabt14intrusive_listINS_4ExprEE5clearEv:
  593|  6.78M|inline void intrusive_list<T>::clear() noexcept {
  594|  7.47M|  for (T* iter = first_; iter;) {
  ------------------
  |  Branch (594:26): [True: 689k, False: 6.78M]
  ------------------
  595|   689k|    T* next = iter->next_;
  596|   689k|    delete iter;
  597|   689k|    iter = next;
  598|   689k|  }
  599|  6.78M|  first_ = last_ = nullptr;
  600|  6.78M|  size_ = 0;
  601|  6.78M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEEaSEOS2_:
  293|    108|    intrusive_list<T>&& other) {
  294|    108|  clear();
  295|    108|  first_ = other.first_;
  296|    108|  last_ = other.last_;
  297|    108|  size_ = other.size_;
  298|    108|  other.first_ = other.last_ = nullptr;
  299|    108|  other.size_ = 0;
  300|    108|  return *this;
  301|    108|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE5beginEv:
  305|  2.75M|intrusive_list<T>::begin() noexcept {
  306|  2.75M|  return iterator(*this, first_);
  307|  2.75M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE8iteratorC2ERKS2_PS1_:
  150|  5.50M|      : list_(&list), node_(node) {}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE3endEv:
  316|  2.75M|inline typename intrusive_list<T>::iterator intrusive_list<T>::end() noexcept {
  317|  2.75M|  return iterator(*this, nullptr);
  318|  2.75M|}
_ZNK4wabt14intrusive_listINS_11ModuleFieldEE8iteratorneES3_:
  190|  4.50M|  bool operator!=(iterator rhs) const {
  191|  4.50M|    assert(list_ == rhs.list_);
  192|  4.50M|    return node_ != rhs.node_;
  193|  4.50M|  }
_ZNK4wabt14intrusive_listINS_11ModuleFieldEE8iteratordeEv:
  152|  1.74M|  reference operator*() const {
  153|  1.74M|    assert(node_);
  154|  1.74M|    return *node_;
  155|  1.74M|  }
_ZN4wabt14intrusive_listINS_11ModuleFieldEE8iteratorppEv:
  162|  1.74M|  iterator& operator++() {
  163|  1.74M|    assert(node_);
  164|  1.74M|    node_ = node_->next_;
  165|  1.74M|    return *this;
  166|  1.74M|  }
_ZN4wabt14intrusive_listINS_11ModuleFieldEE4backEv:
  399|  2.74M|inline typename intrusive_list<T>::reference intrusive_list<T>::back() {
  400|  2.74M|  assert(!empty());
  401|  2.74M|  return *last_;
  402|  2.74M|}
_ZNK4wabt14intrusive_listINS_11ModuleFieldEE5emptyEv:
  381|  5.57M|inline bool intrusive_list<T>::empty() const noexcept {
  382|  5.57M|  return size_ == 0;
  383|  5.57M|}
_ZN4wabt14intrusive_listINS_4ExprEED2Ev:
  287|  6.77M|inline intrusive_list<T>::~intrusive_list() {
  288|  6.77M|  clear();
  289|  6.77M|}
_ZN4wabt14intrusive_listINS_4ExprEEC2Ev:
  267|  6.31M|inline intrusive_list<T>::intrusive_list() {}
_ZNK4wabt14intrusive_listINS_4ExprEE4sizeEv:
  376|   136k|    const noexcept {
  377|   136k|  return size_;
  378|   136k|}
_ZN4wabt14intrusive_listINS_4ExprEEaSEOS2_:
  293|  2.03k|    intrusive_list<T>&& other) {
  294|  2.03k|  clear();
  295|  2.03k|  first_ = other.first_;
  296|  2.03k|  last_ = other.last_;
  297|  2.03k|  size_ = other.size_;
  298|  2.03k|  other.first_ = other.last_ = nullptr;
  299|  2.03k|  other.size_ = 0;
  300|  2.03k|  return *this;
  301|  2.03k|}
_ZN4wabt14intrusive_listINS_4ExprEEC2EOS2_:
  281|   460k|    : first_(other.first_), last_(other.last_), size_(other.size_) {
  282|   460k|  other.first_ = other.last_ = nullptr;
  283|   460k|  other.size_ = 0;
  284|   460k|}
_ZN4wabt14intrusive_listINS_4ExprEE9push_backENSt3__110unique_ptrIS1_NS3_14default_deleteIS1_EEEE:
  444|  18.7M|inline void intrusive_list<T>::push_back(std::unique_ptr<T> node) {
  445|  18.7M|  assert(node->prev_ == nullptr && node->next_ == nullptr);
  446|       |
  447|  18.7M|  T* node_p = node.release();
  448|  18.7M|  if (last_) {
  ------------------
  |  Branch (448:7): [True: 17.9M, False: 764k]
  ------------------
  449|  17.9M|    node_p->prev_ = last_;
  450|  17.9M|    last_->next_ = node_p;
  451|  17.9M|  } else {
  452|   764k|    first_ = node_p;
  453|   764k|  }
  454|  18.7M|  last_ = node_p;
  455|  18.7M|  size_++;
  456|  18.7M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEEC2Ev:
  267|  3.08M|inline intrusive_list<T>::intrusive_list() {}
_ZN4wabt14intrusive_listINS_4ExprEE4backEv:
  399|  18.0M|inline typename intrusive_list<T>::reference intrusive_list<T>::back() {
  400|  18.0M|  assert(!empty());
  401|  18.0M|  return *last_;
  402|  18.0M|}
_ZNK4wabt14intrusive_listINS_4ExprEE5emptyEv:
  381|  36.3M|inline bool intrusive_list<T>::empty() const noexcept {
  382|  36.3M|  return size_ == 0;
  383|  36.3M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE9push_backENSt3__110unique_ptrIS1_NS3_14default_deleteIS1_EEEE:
  444|  3.30M|inline void intrusive_list<T>::push_back(std::unique_ptr<T> node) {
  445|  3.30M|  assert(node->prev_ == nullptr && node->next_ == nullptr);
  446|       |
  447|  3.30M|  T* node_p = node.release();
  448|  3.30M|  if (last_) {
  ------------------
  |  Branch (448:7): [True: 3.29M, False: 14.7k]
  ------------------
  449|  3.29M|    node_p->prev_ = last_;
  450|  3.29M|    last_->next_ = node_p;
  451|  3.29M|  } else {
  452|  14.7k|    first_ = node_p;
  453|  14.7k|  }
  454|  3.30M|  last_ = node_p;
  455|  3.30M|  size_++;
  456|  3.30M|}
_ZN4wabt14intrusive_listINS_4ExprEE3endEv:
  316|  39.2M|inline typename intrusive_list<T>::iterator intrusive_list<T>::end() noexcept {
  317|  39.2M|  return iterator(*this, nullptr);
  318|  39.2M|}
_ZN4wabt14intrusive_listINS_4ExprEE8iteratorC2ERKS2_PS1_:
  150|  60.0M|      : list_(&list), node_(node) {}
_ZN4wabt14intrusive_listINS_4ExprEE6spliceENS2_8iteratorERS2_:
  604|   374k|inline void intrusive_list<T>::splice(iterator pos, intrusive_list& other) {
  605|   374k|  splice(pos, other, other.begin(), other.end());
  606|   374k|}
_ZN4wabt14intrusive_listINS_4ExprEE6spliceENS2_8iteratorERS2_S3_S3_:
  624|   374k|                                      iterator last) {
  625|  18.4M|  while (first != last)
  ------------------
  |  Branch (625:10): [True: 18.0M, False: 374k]
  ------------------
  626|  18.0M|    insert(pos, other.extract(first++));
  627|   374k|}
_ZNK4wabt14intrusive_listINS_4ExprEE8iteratorneES3_:
  190|  39.2M|  bool operator!=(iterator rhs) const {
  191|  39.2M|    assert(list_ == rhs.list_);
  192|  39.2M|    return node_ != rhs.node_;
  193|  39.2M|  }
_ZN4wabt14intrusive_listINS_4ExprEE6insertENS2_8iteratorENSt3__110unique_ptrIS1_NS4_14default_deleteIS1_EEEE:
  514|  18.0M|    std::unique_ptr<T> node) {
  515|  18.0M|  assert(node->prev_ == nullptr && node->next_ == nullptr);
  516|       |
  517|  18.0M|  T* node_p;
  518|  18.0M|  if (pos == end()) {
  ------------------
  |  Branch (518:7): [True: 18.0M, False: 0]
  ------------------
  519|  18.0M|    push_back(std::move(node));
  520|  18.0M|    node_p = &back();
  521|  18.0M|  } else {
  522|      0|    node_p = node.release();
  523|      0|    node_p->prev_ = pos->prev_;
  524|      0|    node_p->next_ = &*pos;
  525|      0|    if (pos->prev_) {
  ------------------
  |  Branch (525:9): [True: 0, False: 0]
  ------------------
  526|      0|      pos->prev_->next_ = node_p;
  527|      0|    } else {
  528|      0|      first_ = node_p;
  529|      0|    }
  530|      0|    pos->prev_ = node_p;
  531|      0|    size_++;
  532|      0|  }
  533|  18.0M|  return iterator(*this, node_p);
  534|  18.0M|}
_ZNK4wabt14intrusive_listINS_4ExprEE8iteratoreqES3_:
  185|  18.0M|  bool operator==(iterator rhs) const {
  186|  18.0M|    assert(list_ == rhs.list_);
  187|  18.0M|    return node_ == rhs.node_;
  188|  18.0M|  }
_ZNK4wabt14intrusive_listINS_4ExprEE8iteratordeEv:
  152|  18.4M|  reference operator*() const {
  153|  18.4M|    assert(node_);
  154|  18.4M|    return *node_;
  155|  18.4M|  }
_ZN4wabt14intrusive_listINS_4ExprEE7extractENS2_8iteratorE:
  544|  18.0M|inline std::unique_ptr<T> intrusive_list<T>::extract(iterator pos) {
  545|  18.0M|  assert(!empty());
  546|  18.0M|  assert(pos != end());
  547|  18.0M|  T* node = &*pos;
  548|  18.0M|  if (first_ == last_) {
  ------------------
  |  Branch (548:7): [True: 374k, False: 17.6M]
  ------------------
  549|   374k|    first_ = last_ = nullptr;
  550|  17.6M|  } else {
  551|  17.6M|    if (node->prev_) {
  ------------------
  |  Branch (551:9): [True: 0, False: 17.6M]
  ------------------
  552|      0|      node->prev_->next_ = node->next_;
  553|  17.6M|    } else {
  554|  17.6M|      first_ = node->next_;
  555|  17.6M|    }
  556|       |
  557|  17.6M|    if (node->next_) {
  ------------------
  |  Branch (557:9): [True: 17.6M, False: 0]
  ------------------
  558|  17.6M|      node->next_->prev_ = node->prev_;
  559|  17.6M|    } else {
  560|      0|      last_ = node->prev_;
  561|      0|    }
  562|  17.6M|  }
  563|  18.0M|  node->next_ = node->prev_ = nullptr;
  564|  18.0M|  size_--;
  565|  18.0M|  return std::unique_ptr<T>(node);
  566|  18.0M|}
_ZN4wabt14intrusive_listINS_4ExprEE8iteratorppEi:
  168|  18.0M|  iterator operator++(int) {
  169|  18.0M|    iterator tmp = *this;
  170|  18.0M|    operator++();
  171|  18.0M|    return tmp;
  172|  18.0M|  }
_ZN4wabt14intrusive_listINS_4ExprEE8iteratorppEv:
  162|  18.4M|  iterator& operator++() {
  163|  18.4M|    assert(node_);
  164|  18.4M|    node_ = node_->next_;
  165|  18.4M|    return *this;
  166|  18.4M|  }
_ZN4wabt14intrusive_listINS_4ExprEE5beginEv:
  305|  2.76M|intrusive_list<T>::begin() noexcept {
  306|  2.76M|  return iterator(*this, first_);
  307|  2.76M|}
_ZN4wabt14intrusive_listINS_11ModuleFieldEE13extract_frontEv:
  474|  42.4k|inline std::unique_ptr<T> intrusive_list<T>::extract_front() {
  475|  42.4k|  assert(!empty());
  476|  42.4k|  T* node = first_;
  477|  42.4k|  if (first_ == last_) {
  ------------------
  |  Branch (477:7): [True: 2.73k, False: 39.7k]
  ------------------
  478|  2.73k|    first_ = last_ = nullptr;
  479|  39.7k|  } else {
  480|  39.7k|    first_ = first_->next_;
  481|  39.7k|    first_->prev_ = nullptr;
  482|  39.7k|  }
  483|  42.4k|  node->next_ = node->prev_ = nullptr;
  484|  42.4k|  size_--;
  485|  42.4k|  return std::unique_ptr<T>(node);
  486|  42.4k|}
_ZN4wabt14intrusive_listINS_4ExprEE5frontEv:
  386|   267k|inline typename intrusive_list<T>::reference intrusive_list<T>::front() {
  387|   267k|  assert(!empty());
  388|   267k|  return *first_;
  389|   267k|}

_ZNK4wabt3Var8is_indexEv:
   55|  5.16M|  bool is_index() const { return type_ == VarType::Index; }
_ZNK4wabt3Var7is_nameEv:
   56|  15.7M|  bool is_name() const { return type_ == VarType::Name; }
_ZNK4wabt3Var5indexEv:
   58|   587k|  Index index() const {
   59|   587k|    assert(is_index());
   60|   587k|    return index_;
   61|   587k|  }
_ZNK4wabt3Var4nameEv:
   62|   994k|  const std::string& name() const {
   63|   994k|    assert(is_name());
   64|   994k|    return name_;
   65|   994k|  }
_ZN4wabt5ConstC2Ev:
   87|   429k|  Const() : Const(Type::I32, uint32_t(0)) {}
_ZN4wabt5Const3I32EjRKNS_8LocationE:
   89|  1.52k|  static Const I32(uint32_t val = 0, const Location& loc = Location()) {
   90|  1.52k|    return Const(Type::I32, val, loc);
   91|  1.52k|  }
_ZN4wabt5Const3I64EmRKNS_8LocationE:
   92|    448|  static Const I64(uint64_t val = 0, const Location& loc = Location()) {
   93|    448|    return Const(Type::I64, val, loc);
   94|    448|  }
_ZNK4wabt5Const8f32_bitsEv:
  125|  7.20k|  uint32_t f32_bits() const { return data_.f32_bits(0); }
_ZNK4wabt5Const8f64_bitsEv:
  126|  93.1k|  uint64_t f64_bits() const { return data_.f64_bits(0); }
_ZN4wabt5Const7set_u32Ej:
  135|  10.7k|  void set_u32(uint32_t x) { From(Type::I32, x); }
_ZN4wabt5Const7set_u64Em:
  136|    991|  void set_u64(uint64_t x) { From(Type::I64, x); }
_ZN4wabt5Const7set_f32Ej:
  137|   127k|  void set_f32(uint32_t x) { From(Type::F32, x); }
_ZN4wabt5Const7set_f64Em:
  138|   183k|  void set_f64(uint64_t x) { From(Type::F64, x); }
_ZN4wabt5Const11set_v128_u8Eih:
  140|  2.52k|  void set_v128_u8(int lane, uint8_t x) { set_v128_lane(lane, Type::I8, x); }
_ZN4wabt5Const12set_v128_u16Eit:
  141|  4.40k|  void set_v128_u16(int lane, uint16_t x) { set_v128_lane(lane, Type::I16, x); }
_ZN4wabt5Const12set_v128_u32Eij:
  142|    978|  void set_v128_u32(int lane, uint32_t x) { set_v128_lane(lane, Type::I32, x); }
_ZN4wabt5Const12set_v128_u64Eim:
  143|    999|  void set_v128_u64(int lane, uint64_t x) { set_v128_lane(lane, Type::I64, x); }
_ZN4wabt5Const12set_v128_f32Eij:
  144|  7.20k|  void set_v128_f32(int lane, uint32_t x) { set_v128_lane(lane, Type::F32, x); }
_ZN4wabt5Const12set_v128_f64Eim:
  145|  93.1k|  void set_v128_f64(int lane, uint64_t x) { set_v128_lane(lane, Type::F64, x); }
_ZNK4wabt5Const12expected_nanEi:
  164|   100k|  ExpectedNan expected_nan(int lane = 0) const {
  165|   100k|    return lane < 4 ? nan_[lane] : ExpectedNan::None;
  ------------------
  |  Branch (165:12): [True: 100k, False: 0]
  ------------------
  166|   100k|  }
_ZN4wabt5Const16set_expected_nanEiNS_11ExpectedNanE:
  168|  1.07M|  void set_expected_nan(int lane, ExpectedNan nan) {
  169|  1.07M|    if (lane < 4) {
  ------------------
  |  Branch (169:9): [True: 1.07M, False: 2.64k]
  ------------------
  170|  1.07M|      nan_[lane] = nan;
  171|  1.07M|    }
  172|  1.07M|  }
_ZNK4wabt13FuncSignature12GetNumParamsEv:
  258|  1.77M|  Index GetNumParams() const { return param_types.size(); }
_ZNK4wabt13FuncSignature13GetNumResultsEv:
  259|  42.4k|  Index GetNumResults() const { return result_types.size(); }
_ZNK4wabt9TypeEntry4kindEv:
  278|  2.29M|  TypeEntryKind kind() const { return kind_; }
_ZN4wabt9TypeEntryC2ENS_13TypeEntryKindENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_8LocationE:
  287|   113k|      : loc(loc), name(name), kind_(kind) {}
_ZN4wabt8FuncType7classofEPKNS_9TypeEntryE:
  294|  2.29M|  static bool classof(const TypeEntry* entry) {
  295|  2.29M|    return entry->kind() == TypeEntryKind::Func;
  296|  2.29M|  }
_ZN4wabt8FuncTypeC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  299|   110k|      : TypeEntry(TypeEntryKind::Func, name) {}
_ZN4wabt9ArrayTypeC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  341|  3.13k|      : TypeEntry(TypeEntryKind::Array) {}
_ZNK4wabt15FuncDeclaration12GetNumParamsEv:
  347|  1.73M|  Index GetNumParams() const { return sig.GetNumParams(); }
_ZN4wabt5CatchC2ERKNS_8LocationE:
  446|  18.1k|  explicit Catch(const Location& loc = Location()) : loc(loc) {}
_ZNK4wabt5Catch10IsCatchAllEv:
  452|  10.9k|  bool IsCatchAll() const {
  453|  10.9k|    return var.is_index() && var.index() == kInvalidIndex;
  ------------------
  |  Branch (453:12): [True: 9.24k, False: 1.75k]
  |  Branch (453:30): [True: 8.75k, False: 494]
  ------------------
  454|  10.9k|  }
_ZN4wabt10TableCatchC2ERKNS_8LocationE:
  459|  4.94k|  explicit TableCatch(const Location& loc = Location()) : loc(loc) {}
_ZNK4wabt10TableCatch10IsCatchAllEv:
  464|  1.53k|  bool IsCatchAll() const {
  465|  1.53k|    return kind == CatchKind::CatchAll || kind == CatchKind::CatchAllRef;
  ------------------
  |  Branch (465:12): [True: 196, False: 1.33k]
  |  Branch (465:43): [True: 0, False: 1.33k]
  ------------------
  466|  1.53k|  }
_ZNK4wabt4Expr4typeEv:
  481|  1.24M|  ExprType type() const { return type_; }
_ZN4wabt4ExprC2ENS_8ExprTypeERKNS_8LocationE:
  487|  1.10M|      : loc(loc), type_(type) {}
_ZN4wabt14SimdLaneOpExprC2ENS_6OpcodeEmRKNS_8LocationE:
  567|    446|      : ExprMixin<ExprType::SimdLaneOp>(loc), opcode(opcode), val(val) {}
_ZN4wabt16SimdLoadLaneExprC2ENS_6OpcodeENS_3VarEmmmRKNS_8LocationE:
  581|    345|      : MemoryExpr<ExprType::SimdLoadLane>(memidx, loc),
  582|    345|        opcode(opcode),
  583|    345|        align(align),
  584|    345|        offset(offset),
  585|    345|        val(val) {}
_ZN4wabt17SimdStoreLaneExprC2ENS_6OpcodeENS_3VarEmmmRKNS_8LocationE:
  601|    547|      : MemoryExpr<ExprType::SimdStoreLane>(memidx, loc),
  602|    547|        opcode(opcode),
  603|    547|        align(align),
  604|    547|        offset(offset),
  605|    547|        val(val) {}
_ZN4wabt17SimdShuffleOpExprC2ENS_6OpcodeE4v128RKNS_8LocationE:
  616|    310|      : ExprMixin<ExprType::SimdShuffleOp>(loc), opcode(opcode), val(val) {}
_ZN4wabt10SelectExprC2ENSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEERKNS_8LocationE:
  666|  1.24k|      : ExprMixin<ExprType::Select>(loc), result_type(type) {}
_ZN4wabt13TableInitExprC2ERKNS_3VarES3_RKNS_8LocationE:
  675|  4.71k|      : ExprMixin<ExprType::TableInit>(loc),
  676|  4.71k|        segment_index(segment_index),
  677|  4.71k|        table_index(table_index) {}
_ZN4wabt13TableCopyExprC2ERKNS_3VarES3_RKNS_8LocationE:
  688|  2.55k|      : ExprMixin<ExprType::TableCopy>(loc), dst_table(dst), src_table(src) {}
_ZN4wabt16CallIndirectExprC2ERKNS_8LocationE:
  697|  3.71k|      : ExprMixin<ExprType::CallIndirect>(loc) {}
_ZN4wabt16CodeMetadataExprC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS1_6vectorIhNS1_9allocatorIhEEEERKNS_8LocationE:
  708|  4.78k|      : ExprMixin<ExprType::CodeMetadata>(loc),
  709|  4.78k|        name(std::move(name)),
  710|  4.78k|        data(std::move(data)) {}
_ZN4wabt22ReturnCallIndirectExprC2ERKNS_8LocationE:
  719|  3.74k|      : ExprMixin<ExprType::ReturnCallIndirect>(loc) {}
_ZN4wabt11CallRefExprC2ERKNS_8LocationE:
  728|    431|      : ExprMixin<ExprType::CallRef>(loc) {}
_ZN4wabt6IfExprC2ERKNS_8LocationE:
  750|   139k|      : ExprMixin<ExprType::If>(loc) {}
_ZN4wabt12TryTableExprC2ERKNS_8LocationE:
  760|  7.59k|      : ExprMixin<ExprType::TryTable>(loc) {}
_ZN4wabt7TryExprC2ERKNS_8LocationE:
  769|  79.1k|      : ExprMixin<ExprType::Try>(loc), kind(TryKind::Plain) {}
_ZN4wabt11BrTableExprC2ERKNS_8LocationE:
  780|  5.70k|      : ExprMixin<ExprType::BrTable>(loc) {}
_ZN4wabt9ConstExprC2ERKNS_5ConstERKNS_8LocationE:
  789|   246k|      : ExprMixin<ExprType::Const>(loc), const_(c) {}
_ZN4wabt15AtomicFenceExprC2EjRKNS_8LocationE:
  829|    500|      : ExprMixin<ExprType::AtomicFence>(loc),
  830|    500|        consistency_model(consistency_model) {}
_ZN4wabt3TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  836|  65.9k|  explicit Tag(std::string_view name) : name(name) {}
_ZN4wabt4FuncC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  904|  1.81M|  explicit Func(std::string_view name) : name(name) {}
_ZNK4wabt4Func12GetNumParamsEv:
  910|  1.73M|  Index GetNumParams() const { return decl.GetNumParams(); }
_ZN4wabt6GlobalC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  934|   525k|  explicit Global(std::string_view name) : name(name) {}
_ZN4wabt5TableC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  944|   174k|      : name(name), elem_type(Type::FuncRef) {}
_ZN4wabt11ElemSegmentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  954|   263k|  explicit ElemSegment(std::string_view name) : name(name) {}
_ZN4wabt6MemoryC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  966|   554k|  explicit Memory(std::string_view name) : name(name) {}
_ZN4wabt11DataSegmentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  974|  97.7k|  explicit DataSegment(std::string_view name) : name(name) {}
_ZNK4wabt6Import4kindEv:
  990|   494k|  ExternalKind kind() const { return kind_; }
_ZN4wabt6ImportC2ENS_12ExternalKindE:
  996|   297k|  Import(ExternalKind kind) : kind_(kind) {}
_ZN4wabt10FuncImportC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1014|  87.8k|      : ImportMixin<ExternalKind::Func>(), func(name) {}
_ZN4wabt11TableImportC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1022|  29.1k|      : ImportMixin<ExternalKind::Table>(), table(name) {}
_ZN4wabt12MemoryImportC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1030|  5.95k|      : ImportMixin<ExternalKind::Memory>(), memory(name) {}
_ZN4wabt12GlobalImportC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1038|   108k|      : ImportMixin<ExternalKind::Global>(), global(name) {}
_ZN4wabt9TagImportC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1046|  65.9k|      : ImportMixin<ExternalKind::Tag>(), tag(name) {}
_ZNK4wabt11ModuleField4typeEv:
 1077|  3.26M|  ModuleFieldType type() const { return type_; }
_ZN4wabt11ModuleFieldC2ENS_15ModuleFieldTypeERKNS_8LocationE:
 1083|  3.56M|      : loc(loc), type_(type) {}
_ZN4wabt15FuncModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1104|  1.72M|      : ModuleFieldMixin<ModuleFieldType::Func>(loc), func(name) {}
_ZN4wabt17GlobalModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1113|   416k|      : ModuleFieldMixin<ModuleFieldType::Global>(loc), global(name) {}
_ZN4wabt17ImportModuleFieldC2ENSt3__110unique_ptrINS_6ImportENS1_14default_deleteIS3_EEEERKNS_8LocationE:
 1124|   181k|      : ModuleFieldMixin<ModuleFieldType::Import>(loc),
 1125|   181k|        import(std::move(import)) {}
_ZN4wabt17ExportModuleFieldC2ERKNS_8LocationE:
 1133|  61.6k|      : ModuleFieldMixin<ModuleFieldType::Export>(loc) {}
_ZN4wabt15TypeModuleFieldC2ERKNS_8LocationE:
 1141|   128k|      : ModuleFieldMixin<ModuleFieldType::Type>(loc) {}
_ZN4wabt16TableModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1150|   145k|      : ModuleFieldMixin<ModuleFieldType::Table>(loc), table(name) {}
_ZN4wabt22ElemSegmentModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1160|   263k|      : ModuleFieldMixin<ModuleFieldType::ElemSegment>(loc),
 1161|   263k|        elem_segment(name) {}
_ZN4wabt17MemoryModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1170|   548k|      : ModuleFieldMixin<ModuleFieldType::Memory>(loc), memory(name) {}
_ZN4wabt22DataSegmentModuleFieldC2ERKNS_8LocationENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1180|  97.7k|      : ModuleFieldMixin<ModuleFieldType::DataSegment>(loc),
 1181|  97.7k|        data_segment(name) {}
_ZN4wabt16StartModuleFieldC2ENS_3VarERKNS_8LocationE:
 1198|     79|      : ModuleFieldMixin<ModuleFieldType::Start>(loc), start(start) {}
_ZNK4wabt12ScriptModule4typeEv:
 1327|    108|  ScriptModuleType type() const { return type_; }
_ZN4wabt12ScriptModuleC2ENS_16ScriptModuleTypeE:
 1331|     80|  explicit ScriptModule(ScriptModuleType type) : type_(type) {}
_ZN4wabt7CommandC2ENS_11CommandTypeE:
 1445|     54|  explicit Command(CommandType type) : type(type) {}
_ZN4wabt5Const4FromIjEEvNS_4TypeET_i:
  191|   577k|  void From(Type type, T data, int lane = 0) {
  192|   577k|    static_assert(sizeof(T) <= sizeof(data_), "Invalid cast!");
  193|   577k|    assert((lane + 1) * sizeof(T) <= sizeof(data_));
  194|   577k|    type_ = type;
  195|   577k|    data_.From<T>(lane, data);
  196|   577k|    set_expected_nan(lane, ExpectedNan::None);
  197|   577k|  }
_ZN4wabt5Const4FromImEEvNS_4TypeET_i:
  191|   278k|  void From(Type type, T data, int lane = 0) {
  192|   278k|    static_assert(sizeof(T) <= sizeof(data_), "Invalid cast!");
  193|   278k|    assert((lane + 1) * sizeof(T) <= sizeof(data_));
  194|   278k|    type_ = type;
  195|   278k|    data_.From<T>(lane, data);
  196|   278k|    set_expected_nan(lane, ExpectedNan::None);
  197|   278k|  }
_ZN4wabt5Const13set_v128_laneIhEEviNS_4TypeET_:
  179|  2.52k|  void set_v128_lane(int lane, Type lane_type, T x) {
  180|  2.52k|    lane_type_ = lane_type;
  181|  2.52k|    From(Type::V128, x, lane);
  182|  2.52k|    set_expected_nan(lane, ExpectedNan::None);
  183|  2.52k|  }
_ZN4wabt5Const4FromIhEEvNS_4TypeET_i:
  191|  2.52k|  void From(Type type, T data, int lane = 0) {
  192|  2.52k|    static_assert(sizeof(T) <= sizeof(data_), "Invalid cast!");
  193|  2.52k|    assert((lane + 1) * sizeof(T) <= sizeof(data_));
  194|  2.52k|    type_ = type;
  195|  2.52k|    data_.From<T>(lane, data);
  196|  2.52k|    set_expected_nan(lane, ExpectedNan::None);
  197|  2.52k|  }
_ZN4wabt5Const13set_v128_laneItEEviNS_4TypeET_:
  179|  4.40k|  void set_v128_lane(int lane, Type lane_type, T x) {
  180|  4.40k|    lane_type_ = lane_type;
  181|  4.40k|    From(Type::V128, x, lane);
  182|  4.40k|    set_expected_nan(lane, ExpectedNan::None);
  183|  4.40k|  }
_ZN4wabt5Const4FromItEEvNS_4TypeET_i:
  191|  4.40k|  void From(Type type, T data, int lane = 0) {
  192|  4.40k|    static_assert(sizeof(T) <= sizeof(data_), "Invalid cast!");
  193|  4.40k|    assert((lane + 1) * sizeof(T) <= sizeof(data_));
  194|  4.40k|    type_ = type;
  195|  4.40k|    data_.From<T>(lane, data);
  196|  4.40k|    set_expected_nan(lane, ExpectedNan::None);
  197|  4.40k|  }
_ZN4wabt5Const13set_v128_laneIjEEviNS_4TypeET_:
  179|  8.18k|  void set_v128_lane(int lane, Type lane_type, T x) {
  180|  8.18k|    lane_type_ = lane_type;
  181|  8.18k|    From(Type::V128, x, lane);
  182|  8.18k|    set_expected_nan(lane, ExpectedNan::None);
  183|  8.18k|  }
_ZN4wabt5Const13set_v128_laneImEEviNS_4TypeET_:
  179|  94.1k|  void set_v128_lane(int lane, Type lane_type, T x) {
  180|  94.1k|    lane_type_ = lane_type;
  181|  94.1k|    From(Type::V128, x, lane);
  182|  94.1k|    set_expected_nan(lane, ExpectedNan::None);
  183|  94.1k|  }
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE0EE7classofEPKNS_11ModuleFieldE:
 1093|  1.70M|  static bool classof(const ModuleField* field) {
 1094|  1.70M|    return field->type() == TypeEnum;
 1095|  1.70M|  }
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE10EE7classofEPKNS_11ModuleFieldE:
 1093|   717k|  static bool classof(const ModuleField* field) {
 1094|   717k|    return field->type() == TypeEnum;
 1095|   717k|  }
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE2EE7classofEPKNS_11ModuleFieldE:
 1093|   717k|  static bool classof(const ModuleField* field) {
 1094|   717k|    return field->type() == TypeEnum;
 1095|   717k|  }
_ZN4wabt11ImportMixinILNS_12ExternalKindE0EE7classofEPKNS_6ImportE:
 1004|   142k|  static bool classof(const Import* import) {
 1005|   142k|    return import->kind() == TypeEnum;
 1006|   142k|  }
_ZN4wabt11ImportMixinILNS_12ExternalKindE4EE7classofEPKNS_6ImportE:
 1004|   126k|  static bool classof(const Import* import) {
 1005|   126k|    return import->kind() == TypeEnum;
 1006|   126k|  }
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE4EEC2ERKNS_8LocationE:
 1097|   128k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt11ModuleFieldD2Ev:
 1075|  3.56M|  virtual ~ModuleField() = default;
_ZN4wabt9TypeEntryD2Ev:
  276|   113k|  virtual ~TypeEntry() = default;
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE3EE7classofEPKNS_11ModuleFieldE:
 1093|  84.9k|  static bool classof(const ModuleField* field) {
 1094|  84.9k|    return field->type() == TypeEnum;
 1095|  84.9k|  }
_ZN4wabt5ConstC2ImEENS_4TypeET_RKNS_8LocationE:
  186|    448|  Const(Type type, T data, const Location& loc = Location()) : loc(loc) {
  187|    448|    From<T>(type, data);
  188|    448|  }
_ZN4wabt5ConstC2IjEENS_4TypeET_RKNS_8LocationE:
  186|   431k|  Const(Type type, T data, const Location& loc = Location()) : loc(loc) {
  187|   431k|    From<T>(type, data);
  188|   431k|  }
_ZN4wabt9ExprMixinILNS_8ExprTypeE42EEC2ERKNS_8LocationE:
  499|  1.24k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt4ExprD2Ev:
  479|  1.10M|  virtual ~Expr() = default;
_ZN4wabt9ExprMixinILNS_8ExprTypeE14EEC2ERKNS_8LocationE:
  499|    431|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE17EEC2ERKNS_8LocationE:
  499|   246k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE50EEC2ERKNS_8LocationE:
  499|  2.55k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE52EEC2ERKNS_8LocationE:
  499|  4.71k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE5EEC2ERKNS_8LocationE:
  499|    500|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE43EEC2ERKNS_8LocationE:
  499|    446|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE46EEC2ERKNS_8LocationE:
  499|    310|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7CommandD2Ev:
 1440|     54|  virtual ~Command() = default;
_ZN4wabt7VarExprILNS_8ExprTypeE36EEC2ERKNS_3VarERKNS_8LocationE:
  626|   155k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE36EEC2ERKNS_8LocationE:
  499|   155k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt12CommandMixinILNS_11CommandTypeE0EE7classofEPKNS_7CommandE:
 1451|    108|  static bool classof(const Command* cmd) { return cmd->type == TypeEnum; }
_ZN4wabt12CommandMixinILNS_11CommandTypeE0EEC2Ev:
 1452|     54|  CommandMixin() : Command(TypeEnum) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE8EEC2ERKNS_8LocationE:
 1097|  97.7k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE6EEC2ERKNS_8LocationE:
 1097|   263k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt11ImportMixinILNS_12ExternalKindE4EEC2Ev:
 1008|  65.9k|  ImportMixin() : Import(TypeEnum) {}
_ZN4wabt6ImportD2Ev:
  988|   297k|  virtual ~Import() = default;
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE2EEC2ERKNS_8LocationE:
 1097|   181k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE3EEC2ERKNS_8LocationE:
 1097|  61.6k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt11ImportMixinILNS_12ExternalKindE0EEC2Ev:
 1008|  87.8k|  ImportMixin() : Import(TypeEnum) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE0EEC2ERKNS_8LocationE:
 1097|  1.72M|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt11ImportMixinILNS_12ExternalKindE3EEC2Ev:
 1008|   108k|  ImportMixin() : Import(TypeEnum) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE1EEC2ERKNS_8LocationE:
 1097|   416k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt11ImportMixinILNS_12ExternalKindE1EEC2Ev:
 1008|  29.1k|  ImportMixin() : Import(TypeEnum) {}
_ZN4wabt11ImportMixinILNS_12ExternalKindE2EEC2Ev:
 1008|  5.95k|  ImportMixin() : Import(TypeEnum) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE7EEC2ERKNS_8LocationE:
 1097|   548k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE9EEC2ERKNS_8LocationE:
 1097|     79|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt16ModuleFieldMixinILNS_15ModuleFieldTypeE5EEC2ERKNS_8LocationE:
 1097|   145k|  explicit ModuleFieldMixin(const Location& loc) : ModuleField(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE15EEC2ERKNS_8LocationE:
  499|  4.78k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE64EEC2ERKNS_8LocationE:
  499|    390|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE34EEC2ERKNS_8LocationE:
  499|   201k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE19EEC2ERKNS_8LocationE:
  499|  1.19k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE9EEC2ERKNS_3VarERKNS_8LocationE:
  626|  18.8k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE9EEC2ERKNS_8LocationE:
  499|  18.8k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE10EEC2ERKNS_3VarERKNS_8LocationE:
  626|  2.16k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE10EEC2ERKNS_8LocationE:
  499|  2.16k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE11EEC2ERKNS_8LocationE:
  499|  5.70k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE39EEC2ERKNS_8LocationE:
  499|    765|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE12EEC2ERKNS_3VarERKNS_8LocationE:
  626|  8.15k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE12EEC2ERKNS_8LocationE:
  499|  8.15k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE13EEC2ERKNS_8LocationE:
  499|  3.71k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE40EEC2ERKNS_3VarERKNS_8LocationE:
  626|    889|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE40EEC2ERKNS_8LocationE:
  499|    889|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE41EEC2ERKNS_8LocationE:
  499|  3.74k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE24EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.23k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE24EEC2ERKNS_8LocationE:
  499|  1.23k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE25EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.12k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE25EEC2ERKNS_8LocationE:
  499|  1.12k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE26EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.91k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE26EEC2ERKNS_8LocationE:
  499|  1.91k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE20EEC2ERKNS_3VarERKNS_8LocationE:
  626|    932|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE20EEC2ERKNS_8LocationE:
  499|    932|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE21EEC2ERKNS_3VarERKNS_8LocationE:
  626|    862|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE21EEC2ERKNS_8LocationE:
  499|    862|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE23EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  12.6k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  12.6k|        opcode(opcode),
  805|  12.6k|        align(align),
  806|  12.6k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE23EEC2ENS_3VarERKNS_8LocationE:
  506|  12.6k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE23EEC2ERKNS_8LocationE:
  499|  12.6k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE49EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  1.49k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  1.49k|        opcode(opcode),
  805|  1.49k|        align(align),
  806|  1.49k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE49EEC2ENS_3VarERKNS_8LocationE:
  506|  1.49k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE49EEC2ERKNS_8LocationE:
  499|  1.49k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10OpcodeExprILNS_8ExprTypeE63EEC2ENS_6OpcodeERKNS_8LocationE:
  553|  21.2k|      : ExprMixin<TypeEnum>(loc), opcode(opcode) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE63EEC2ERKNS_8LocationE:
  499|  21.2k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10OpcodeExprILNS_8ExprTypeE7EEC2ENS_6OpcodeERKNS_8LocationE:
  553|  22.4k|      : ExprMixin<TypeEnum>(loc), opcode(opcode) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE7EEC2ERKNS_8LocationE:
  499|  22.4k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10OpcodeExprILNS_8ExprTypeE16EEC2ENS_6OpcodeERKNS_8LocationE:
  553|    470|      : ExprMixin<TypeEnum>(loc), opcode(opcode) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE16EEC2ERKNS_8LocationE:
  499|    470|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10OpcodeExprILNS_8ExprTypeE18EEC2ENS_6OpcodeERKNS_8LocationE:
  553|  2.18k|      : ExprMixin<TypeEnum>(loc), opcode(opcode) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE18EEC2ERKNS_8LocationE:
  499|  2.18k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt16MemoryBinaryExprILNS_8ExprTypeE28EEC2ENS_3VarES3_RKNS_8LocationE:
  517|    673|      : ExprMixin<TypeEnum>(loc),
  518|    673|        destmemidx(destmemidx),
  519|    673|        srcmemidx(srcmemidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE28EEC2ERKNS_8LocationE:
  499|    673|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE30EEC2ENS_3VarERKNS_8LocationE:
  506|    410|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE30EEC2ERKNS_8LocationE:
  499|    410|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE29EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.04k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE29EEC2ERKNS_8LocationE:
  499|  1.04k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13MemoryVarExprILNS_8ExprTypeE32EEC2ERKNS_3VarES3_RKNS_8LocationE:
  635|    909|      : MemoryExpr<TypeEnum>(memidx, loc), var(var) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE32EEC2ENS_3VarERKNS_8LocationE:
  506|    909|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE32EEC2ERKNS_8LocationE:
  499|    909|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE33EEC2ENS_3VarERKNS_8LocationE:
  506|  5.77k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE33EEC2ERKNS_8LocationE:
  499|  5.77k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE31EEC2ENS_3VarERKNS_8LocationE:
  506|    652|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE31EEC2ERKNS_8LocationE:
  499|    652|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE51EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.40k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE51EEC2ERKNS_8LocationE:
  499|  1.40k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE53EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.07k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE53EEC2ERKNS_8LocationE:
  499|  1.07k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE56EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.25k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE56EEC2ERKNS_8LocationE:
  499|  1.25k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE54EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.91k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE54EEC2ERKNS_8LocationE:
  499|  1.91k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE55EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.96k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE55EEC2ERKNS_8LocationE:
  499|  1.96k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE57EEC2ERKNS_3VarERKNS_8LocationE:
  626|  1.18k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE57EEC2ERKNS_8LocationE:
  499|  1.18k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt11RefTypeExprILNS_8ExprTypeE37EEC2ENS_4TypeERKNS_8LocationE:
  541|    503|      : ExprMixin<TypeEnum>(loc), type(type) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE37EEC2ERKNS_8LocationE:
  499|    503|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE35EEC2ERKNS_8LocationE:
  499|    509|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE59EEC2ERKNS_3VarERKNS_8LocationE:
  626|  3.20k|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE59EEC2ERKNS_8LocationE:
  499|  3.20k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE60EEC2ERKNS_8LocationE:
  499|    581|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt7VarExprILNS_8ExprTypeE38EEC2ERKNS_3VarERKNS_8LocationE:
  626|    278|      : ExprMixin<TypeEnum>(loc), var(var) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE38EEC2ERKNS_8LocationE:
  499|    278|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE4EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|    416|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|    416|        opcode(opcode),
  805|    416|        align(align),
  806|    416|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE4EEC2ENS_3VarERKNS_8LocationE:
  506|    416|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE4EEC2ERKNS_8LocationE:
  499|    416|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE6EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|    539|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|    539|        opcode(opcode),
  805|    539|        align(align),
  806|    539|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE6EEC2ENS_3VarERKNS_8LocationE:
  506|    539|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE6EEC2ERKNS_8LocationE:
  499|    539|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE0EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  1.87k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  1.87k|        opcode(opcode),
  805|  1.87k|        align(align),
  806|  1.87k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE0EEC2ENS_3VarERKNS_8LocationE:
  506|  1.87k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE0EEC2ERKNS_8LocationE:
  499|  1.87k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE3EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  1.72k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  1.72k|        opcode(opcode),
  805|  1.72k|        align(align),
  806|  1.72k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE3EEC2ENS_3VarERKNS_8LocationE:
  506|  1.72k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE3EEC2ERKNS_8LocationE:
  499|  1.72k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE1EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  19.3k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  19.3k|        opcode(opcode),
  805|  19.3k|        align(align),
  806|  19.3k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE1EEC2ENS_3VarERKNS_8LocationE:
  506|  19.3k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE1EEC2ERKNS_8LocationE:
  499|  19.3k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13LoadStoreExprILNS_8ExprTypeE2EEC2ENS_6OpcodeENS_3VarEmmRKNS_8LocationE:
  803|  10.0k|      : MemoryExpr<TypeEnum>(memidx, loc),
  804|  10.0k|        opcode(opcode),
  805|  10.0k|        align(align),
  806|  10.0k|        offset(offset) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE2EEC2ENS_3VarERKNS_8LocationE:
  506|  10.0k|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE2EEC2ERKNS_8LocationE:
  499|  10.0k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10OpcodeExprILNS_8ExprTypeE58EEC2ENS_6OpcodeERKNS_8LocationE:
  553|  4.14k|      : ExprMixin<TypeEnum>(loc), opcode(opcode) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE58EEC2ERKNS_8LocationE:
  499|  4.14k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE44EEC2ENS_3VarERKNS_8LocationE:
  506|    345|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE44EEC2ERKNS_8LocationE:
  499|    345|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt10MemoryExprILNS_8ExprTypeE45EEC2ENS_3VarERKNS_8LocationE:
  506|    547|      : ExprMixin<TypeEnum>(loc), memidx(memidx) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE45EEC2ERKNS_8LocationE:
  499|    547|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt13BlockExprBaseILNS_8ExprTypeE8EEC2ERKNS_8LocationE:
  739|  6.59k|      : ExprMixin<TypeEnum>(loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE8EEC2ERKNS_8LocationE:
  499|  6.59k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt5BlockC2Ev:
  436|   310k|  Block() = default;
_ZN4wabt13BlockExprBaseILNS_8ExprTypeE27EEC2ERKNS_8LocationE:
  739|  77.1k|      : ExprMixin<TypeEnum>(loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE27EEC2ERKNS_8LocationE:
  499|  77.1k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE22EEC2ERKNS_8LocationE:
  499|   139k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE61EEC2ERKNS_8LocationE:
  499|  79.1k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE62EEC2ERKNS_8LocationE:
  499|  7.59k|  explicit ExprMixin(const Location& loc = Location()) : Expr(TypeEnum, loc) {}
_ZN4wabt17ScriptModuleMixinILNS_16ScriptModuleTypeE0EE7classofEPKNS_12ScriptModuleE:
 1339|     54|  static bool classof(const ScriptModule* script_module) {
 1340|     54|    return script_module->type() == TypeEnum;
 1341|     54|  }
_ZN4wabt12ScriptModuleD2Ev:
 1325|     80|  virtual ~ScriptModule() = default;
_ZN4wabt17ScriptModuleMixinILNS_16ScriptModuleTypeE0EEC2Ev:
 1343|     80|  ScriptModuleMixin() : ScriptModule(TypeEnum) {}
_ZN4wabt9ExprMixinILNS_8ExprTypeE61EE7classofEPKNS_4ExprE:
  497|   154k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE22EE7classofEPKNS_4ExprE:
  497|  13.0k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE8EE7classofEPKNS_4ExprE:
  497|  22.1k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE27EE7classofEPKNS_4ExprE:
  497|   119k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE62EE7classofEPKNS_4ExprE:
  497|  7.21k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE0EE7classofEPKNS_4ExprE:
  497|    564|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE3EE7classofEPKNS_4ExprE:
  497|  1.12k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE1EE7classofEPKNS_4ExprE:
  497|  1.70k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE2EE7classofEPKNS_4ExprE:
  497|    197|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE6EE7classofEPKNS_4ExprE:
  497|    514|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE5EE7classofEPKNS_4ExprE:
  497|    746|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE4EE7classofEPKNS_4ExprE:
  497|    666|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE7EE7classofEPKNS_4ExprE:
  497|    737|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE9EE7classofEPKNS_4ExprE:
  497|  7.20k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE10EE7classofEPKNS_4ExprE:
  497|    555|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE11EE7classofEPKNS_4ExprE:
  497|  1.15k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE12EE7classofEPKNS_4ExprE:
  497|  4.42k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE13EE7classofEPKNS_4ExprE:
  497|  4.50k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE14EE7classofEPKNS_4ExprE:
  497|    194|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE15EE7classofEPKNS_4ExprE:
  497|  1.74k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE16EE7classofEPKNS_4ExprE:
  497|    644|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE17EE7classofEPKNS_4ExprE:
  497|  52.9k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE18EE7classofEPKNS_4ExprE:
  497|    196|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE19EE7classofEPKNS_4ExprE:
  497|    312|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE20EE7classofEPKNS_4ExprE:
  497|  1.77k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE21EE7classofEPKNS_4ExprE:
  497|  1.49k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE23EE7classofEPKNS_4ExprE:
  497|  1.22k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE24EE7classofEPKNS_4ExprE:
  497|  1.88k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE25EE7classofEPKNS_4ExprE:
  497|  1.89k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE26EE7classofEPKNS_4ExprE:
  497|  1.92k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE28EE7classofEPKNS_4ExprE:
  497|    534|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE29EE7classofEPKNS_4ExprE:
  497|  1.89k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE30EE7classofEPKNS_4ExprE:
  497|    582|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE31EE7classofEPKNS_4ExprE:
  497|    520|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE32EE7classofEPKNS_4ExprE:
  497|  1.72k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE33EE7classofEPKNS_4ExprE:
  497|  3.06k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE50EE7classofEPKNS_4ExprE:
  497|  4.67k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE51EE7classofEPKNS_4ExprE:
  497|  2.41k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE52EE7classofEPKNS_4ExprE:
  497|  7.90k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE53EE7classofEPKNS_4ExprE:
  497|  1.76k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE56EE7classofEPKNS_4ExprE:
  497|  2.44k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE54EE7classofEPKNS_4ExprE:
  497|  1.82k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE55EE7classofEPKNS_4ExprE:
  497|  2.46k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE57EE7classofEPKNS_4ExprE:
  497|  2.21k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE36EE7classofEPKNS_4ExprE:
  497|   135k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE37EE7classofEPKNS_4ExprE:
  497|    194|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE35EE7classofEPKNS_4ExprE:
  497|    706|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE34EE7classofEPKNS_4ExprE:
  497|   125k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE38EE7classofEPKNS_4ExprE:
  497|    520|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE39EE7classofEPKNS_4ExprE:
  497|  1.05k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE40EE7classofEPKNS_4ExprE:
  497|  1.71k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE41EE7classofEPKNS_4ExprE:
  497|  4.50k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE42EE7classofEPKNS_4ExprE:
  497|    208|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE49EE7classofEPKNS_4ExprE:
  497|    686|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE59EE7classofEPKNS_4ExprE:
  497|  3.60k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE60EE7classofEPKNS_4ExprE:
  497|    458|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE63EE7classofEPKNS_4ExprE:
  497|  1.20k|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE58EE7classofEPKNS_4ExprE:
  497|    658|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE43EE7classofEPKNS_4ExprE:
  497|    208|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE44EE7classofEPKNS_4ExprE:
  497|    520|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE45EE7classofEPKNS_4ExprE:
  497|    754|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE46EE7classofEPKNS_4ExprE:
  497|    454|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt9ExprMixinILNS_8ExprTypeE64EE7classofEPKNS_4ExprE:
  497|    258|  static bool classof(const Expr* expr) { return expr->type() == TypeEnum; }
_ZN4wabt11ImportMixinILNS_12ExternalKindE1EE7classofEPKNS_6ImportE:
 1004|  17.2k|  static bool classof(const Import* import) {
 1005|  17.2k|    return import->kind() == TypeEnum;
 1006|  17.2k|  }
_ZN4wabt11ImportMixinILNS_12ExternalKindE2EE7classofEPKNS_6ImportE:
 1004|    698|  static bool classof(const Import* import) {
 1005|    698|    return import->kind() == TypeEnum;
 1006|    698|  }
_ZN4wabt11ImportMixinILNS_12ExternalKindE3EE7classofEPKNS_6ImportE:
 1004|  26.3k|  static bool classof(const Import* import) {
 1005|  26.3k|    return import->kind() == TypeEnum;
 1006|  26.3k|  }

_ZN4wabt11LexerSource4dataEv:
   42|  23.2k|  const void* data() { return data_; }
_ZN4wabt11LexerSource4sizeEv:
   43|  23.2k|  Offset size() { return size_; }

_ZN4wabt9ParseInt8ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPhNS_12ParseIntTypeE:
   81|  2.52k|                        ParseIntType parse_type) {
   82|  2.52k|  return ParseInt8(v.data(), v.data() + v.size(), out, parse_type);
   83|  2.52k|}
_ZN4wabt10ParseInt16ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPtNS_12ParseIntTypeE:
   87|  4.40k|                         ParseIntType parse_type) {
   88|  4.40k|  return ParseInt16(v.data(), v.data() + v.size(), out, parse_type);
   89|  4.40k|}
_ZN4wabt10ParseInt32ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPjNS_12ParseIntTypeE:
   93|  11.7k|                         ParseIntType parse_type) {
   94|  11.7k|  return ParseInt32(v.data(), v.data() + v.size(), out, parse_type);
   95|  11.7k|}
_ZN4wabt10ParseInt64ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPmNS_12ParseIntTypeE:
   99|  21.1k|                         ParseIntType parse_type) {
  100|  21.1k|  return ParseInt64(v.data(), v.data() + v.size(), out, parse_type);
  101|  21.1k|}
_ZN4wabt11ParseUint64ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPm:
  103|   758k|inline Result ParseUint64(std::string_view v, uint64_t* out) {
  104|   758k|  return ParseUint64(v.data(), v.data() + v.size(), out);
  105|   758k|}
_ZN4wabt10ParseFloatENS_11LiteralTypeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPj:
  113|   127k|                         uint32_t* out_bits) {
  114|   127k|  return ParseFloat(literal_type, v.data(), v.data() + v.size(), out_bits);
  115|   127k|}
_ZN4wabt11ParseDoubleENS_11LiteralTypeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  119|   183k|                          uint64_t* out_bits) {
  120|   183k|  return ParseDouble(literal_type, v.data(), v.data() + v.size(), out_bits);
  121|   183k|}

_ZN4wabt6OpcodeC2ENS0_4EnumE:
   52|  1.62k|  Opcode(Enum e) : enum_(e) {}
_ZNK4wabt6OpcodecvNS0_4EnumEEv:
   53|   614k|  operator Enum() const { return enum_; }
_ZNK4wabt6Opcode7GetNameEv:
   61|   163k|  const char* GetName() const { return GetInfo().name; }
_ZN4wabt6Opcode10PrefixCodeEhj:
  109|  1.09k|  static uint32_t PrefixCode(uint8_t prefix, uint32_t code) {
  110|  1.09k|    if (code >= (1 << MAX_OPCODE_BITS)) {
  ------------------
  |  |   32|  1.09k|#define MAX_OPCODE_BITS 9
  ------------------
  |  Branch (110:9): [True: 0, False: 1.09k]
  ------------------
  111|       |      // Clamp to (2^bits - 1), since we know that it is an invalid code.
  112|      0|      code = (1 << MAX_OPCODE_BITS) - 1;
  ------------------
  |  |   32|      0|#define MAX_OPCODE_BITS 9
  ------------------
  113|      0|    }
  114|  1.09k|    return (prefix << MAX_OPCODE_BITS) | code;
  ------------------
  |  |   32|  1.09k|#define MAX_OPCODE_BITS 9
  ------------------
  115|  1.09k|  }

_ZN4wabt6ResultC2Ev:
   28|   394k|  Result() : Result(Ok) {}
_ZN4wabt6ResultC2ENS0_4EnumE:
   29|  63.1M|  Result(Enum e) : enum_(e) {}
_ZNK4wabt6ResultcvNS0_4EnumEEv:
   30|  61.4M|  operator Enum() const { return enum_; }
_ZN4wabtorENS_6ResultES0_:
   37|  2.08M|inline Result operator|(Result lhs, Result rhs) {
   38|  2.08M|  return (lhs == Result::Error || rhs == Result::Error) ? Result::Error
  ------------------
  |  Branch (38:11): [True: 252k, False: 1.83M]
  |  Branch (38:35): [True: 17.1k, False: 1.81M]
  ------------------
   39|  2.08M|                                                        : Result::Ok;
   40|  2.08M|}
_ZN4wabt6ResultoRES0_:
   42|  2.08M|inline Result& Result::operator|=(Result rhs) {
   43|  2.08M|  enum_ = *this | rhs;
   44|  2.08M|  return *this;
   45|  2.08M|}
_ZN4wabt9SucceededENS_6ResultE:
   47|  6.09M|inline bool Succeeded(Result result) {
   48|  6.09M|  return result == Result::Ok;
   49|  6.09M|}
_ZN4wabt6FailedENS_6ResultE:
   50|  49.3M|inline bool Failed(Result result) {
   51|  49.3M|  return result == Result::Error;
   52|  49.3M|}

_ZN4wabt12StringPrintfEPKcz:
   53|  20.3k|    StringPrintf(const char* format, ...) {
   54|  20.3k|  va_list args;
   55|  20.3k|  va_list args_copy;
   56|  20.3k|  va_start(args, format);
   57|  20.3k|  va_copy(args_copy, args);
   58|  20.3k|  size_t len = wabt_vsnprintf(nullptr, 0, format, args) + 1;  // For \0.
  ------------------
  |  |  288|  20.3k|#define wabt_vsnprintf vsnprintf
  ------------------
   59|  20.3k|  std::vector<char> buffer(len);
   60|  20.3k|  va_end(args);
   61|  20.3k|  wabt_vsnprintf(buffer.data(), len, format, args_copy);
  ------------------
  |  |  288|  20.3k|#define wabt_vsnprintf vsnprintf
  ------------------
   62|  20.3k|  va_end(args_copy);
   63|  20.3k|  return std::string(buffer.data(), len - 1);
   64|  20.3k|}

_ZN4wabt7LiteralC2ENS_11LiteralTypeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   29|  1.54M|  Literal(LiteralType type, std::string_view text) : type(type), text(text) {}
_ZNK4wabt5Token10token_typeEv:
   89|   122M|  TokenType token_type() const { return token_type_; }
_ZNK4wabt5Token7HasTextEv:
   91|  13.7M|  bool HasText() const { return IsTokenTypeString(token_type_); }
_ZNK4wabt5Token7HasTypeEv:
   92|  3.54M|  bool HasType() const {
   93|  3.54M|    return IsTokenTypeType(token_type_) || IsTokenTypeRefKind(token_type_);
  ------------------
  |  Branch (93:12): [True: 1.29M, False: 2.25M]
  |  Branch (93:44): [True: 2.25M, False: 0]
  ------------------
   94|  3.54M|  }
_ZNK4wabt5Token9HasOpcodeEv:
   95|  5.70M|  bool HasOpcode() const { return IsTokenTypeOpcode(token_type_); }
_ZNK4wabt5Token10HasLiteralEv:
   96|  6.82M|  bool HasLiteral() const { return IsTokenTypeLiteral(token_type_); }
_ZNK4wabt5Token4textEv:
   98|  2.35M|  std::string_view text() const {
   99|  2.35M|    assert(HasText());
  100|  2.35M|    return text_;
  101|  2.35M|  }
_ZNK4wabt5Token4typeEv:
  103|   616k|  Type type() const {
  104|   616k|    assert(HasType());
  105|   616k|    return type_;
  106|   616k|  }
_ZNK4wabt5Token6opcodeEv:
  108|   738k|  Opcode opcode() const {
  109|   738k|    assert(HasOpcode());
  110|   738k|    return opcode_;
  111|   738k|  }
_ZNK4wabt5Token7literalEv:
  113|  1.09M|  const Literal& literal() const {
  114|  1.09M|    assert(HasLiteral());
  115|  1.09M|    return literal_;
  116|  1.09M|  }
_ZN4wabt15IsTokenTypeBareENS_9TokenTypeE:
   50|  27.5M|inline bool IsTokenTypeBare(TokenType token_type) {
   51|  27.5M|  return token_type >= TokenType::First_Bare &&
  ------------------
  |  Branch (51:10): [True: 27.5M, False: 0]
  ------------------
   52|  27.5M|         token_type <= TokenType::Last_Bare;
  ------------------
  |  Branch (52:10): [True: 19.5M, False: 8.02M]
  ------------------
   53|  27.5M|}
_ZN4wabt17IsTokenTypeStringENS_9TokenTypeE:
   55|  13.7M|inline bool IsTokenTypeString(TokenType token_type) {
   56|  13.7M|  return token_type >= TokenType::First_String &&
  ------------------
  |  Branch (56:10): [True: 13.7M, False: 0]
  ------------------
   57|  13.7M|         token_type <= TokenType::Last_String;
  ------------------
  |  Branch (57:10): [True: 13.6M, False: 78.6k]
  ------------------
   58|  13.7M|}
_ZN4wabt15IsTokenTypeTypeENS_9TokenTypeE:
   60|  7.71M|inline bool IsTokenTypeType(TokenType token_type) {
   61|  7.71M|  return token_type == TokenType::ValueType;
   62|  7.71M|}
_ZN4wabt17IsTokenTypeOpcodeENS_9TokenTypeE:
   64|  6.95M|inline bool IsTokenTypeOpcode(TokenType token_type) {
   65|  6.95M|  return token_type >= TokenType::First_Opcode &&
  ------------------
  |  Branch (65:10): [True: 6.95M, False: 0]
  ------------------
   66|  6.95M|         token_type <= TokenType::Last_Opcode;
  ------------------
  |  Branch (66:10): [True: 3.24M, False: 3.71M]
  ------------------
   67|  6.95M|}
_ZN4wabt18IsTokenTypeLiteralENS_9TokenTypeE:
   69|  6.82M|inline bool IsTokenTypeLiteral(TokenType token_type) {
   70|  6.82M|  return token_type >= TokenType::First_Literal &&
  ------------------
  |  Branch (70:10): [True: 6.82M, False: 1.23k]
  ------------------
   71|  6.82M|         token_type <= TokenType::Last_Literal;
  ------------------
  |  Branch (71:10): [True: 3.10M, False: 3.72M]
  ------------------
   72|  6.82M|}
_ZN4wabt18IsTokenTypeRefKindENS_9TokenTypeE:
   74|  5.83M|inline bool IsTokenTypeRefKind(TokenType token_type) {
   75|  5.83M|  return token_type >= TokenType::First_RefKind &&
  ------------------
  |  Branch (75:10): [True: 4.57M, False: 1.25M]
  ------------------
   76|  5.83M|         token_type <= TokenType::Last_RefKind;
  ------------------
  |  Branch (76:10): [True: 4.57M, False: 0]
  ------------------
   77|  5.83M|}

_ZN4wabt4TypeC2Ei:
   63|   481k|      : enum_(static_cast<Enum>(code)), type_index_(0) {
   64|   481k|    assert(!EnumIsReferenceWithIndex(enum_));
   65|   481k|  }
_ZN4wabt4TypeC2ENS0_4EnumE:
   66|  1.93M|  Type(Enum e) : enum_(e), type_index_(0) {
   67|  1.93M|    assert(!EnumIsReferenceWithIndex(enum_));
   68|  1.93M|  }
_ZNK4wabt4TypecvNS0_4EnumEEv:
   72|   964k|  constexpr operator Enum() const { return enum_; }
_ZN4wabteqENS_4TypeES0_:
   74|  43.6k|  friend constexpr bool operator==(const Type a, const Type b) {
   75|  43.6k|    return a.enum_ == b.enum_ && a.type_index_ == b.type_index_;
  ------------------
  |  Branch (75:12): [True: 16.2k, False: 27.3k]
  |  Branch (75:34): [True: 16.2k, False: 0]
  ------------------
   76|  43.6k|  }
_ZN4wabtneENS_4TypeES0_:
   77|  38.5k|  friend constexpr bool operator!=(const Type a, const Type b) {
   78|  38.5k|    return !(a == b);
   79|  38.5k|  }
_ZN4wabteqENS_4TypeENS0_4EnumE:
   80|   134k|  friend constexpr bool operator==(const Type ty, const Enum code) {
   81|   134k|    return ty.enum_ == code;
   82|   134k|  }
_ZNK4wabt4Type7GetNameEv:
  103|  44.5k|  std::string GetName() const {
  104|  44.5k|    switch (enum_) {
  105|  24.8k|      case Type::I32:       return "i32";
  ------------------
  |  Branch (105:7): [True: 24.8k, False: 19.7k]
  ------------------
  106|  15.5k|      case Type::I64:       return "i64";
  ------------------
  |  Branch (106:7): [True: 15.5k, False: 28.9k]
  ------------------
  107|  1.39k|      case Type::F32:       return "f32";
  ------------------
  |  Branch (107:7): [True: 1.39k, False: 43.1k]
  ------------------
  108|    923|      case Type::F64:       return "f64";
  ------------------
  |  Branch (108:7): [True: 923, False: 43.6k]
  ------------------
  109|    213|      case Type::V128:      return "v128";
  ------------------
  |  Branch (109:7): [True: 213, False: 44.3k]
  ------------------
  110|      0|      case Type::I8:        return "i8";
  ------------------
  |  Branch (110:7): [True: 0, False: 44.5k]
  ------------------
  111|      0|      case Type::I16:       return "i16";
  ------------------
  |  Branch (111:7): [True: 0, False: 44.5k]
  ------------------
  112|  1.22k|      case Type::ExnRef:    return "exnref";
  ------------------
  |  Branch (112:7): [True: 1.22k, False: 43.3k]
  ------------------
  113|    194|      case Type::FuncRef:   return "funcref";
  ------------------
  |  Branch (113:7): [True: 194, False: 44.3k]
  ------------------
  114|      0|      case Type::Func:      return "func";
  ------------------
  |  Branch (114:7): [True: 0, False: 44.5k]
  ------------------
  115|      0|      case Type::Void:      return "void";
  ------------------
  |  Branch (115:7): [True: 0, False: 44.5k]
  ------------------
  116|      0|      case Type::Any:       return "any";
  ------------------
  |  Branch (116:7): [True: 0, False: 44.5k]
  ------------------
  117|    196|      case Type::ExternRef: return "externref";
  ------------------
  |  Branch (117:7): [True: 196, False: 44.3k]
  ------------------
  118|      0|      case Type::Reference:
  ------------------
  |  Branch (118:7): [True: 0, False: 44.5k]
  ------------------
  119|      0|        return StringPrintf("(ref %d)", type_index_);
  120|      0|      default:
  ------------------
  |  Branch (120:7): [True: 0, False: 44.5k]
  ------------------
  121|      0|        return StringPrintf("<type_index[%d]>", enum_);
  122|  44.5k|    }
  123|  44.5k|  }
_ZNK4wabt4Type14GetRefKindNameEv:
  125|  65.8k|  const char* GetRefKindName() const {
  126|  65.8k|    switch (enum_) {
  127|  65.4k|      case Type::FuncRef:   return "func";
  ------------------
  |  Branch (127:7): [True: 65.4k, False: 465]
  ------------------
  128|    198|      case Type::ExternRef: return "extern";
  ------------------
  |  Branch (128:7): [True: 198, False: 65.6k]
  ------------------
  129|    267|      case Type::ExnRef:    return "exn";
  ------------------
  |  Branch (129:7): [True: 267, False: 65.6k]
  ------------------
  130|      0|      case Type::Struct:    return "struct";
  ------------------
  |  Branch (130:7): [True: 0, False: 65.8k]
  ------------------
  131|      0|      case Type::Array:     return "array";
  ------------------
  |  Branch (131:7): [True: 0, False: 65.8k]
  ------------------
  132|      0|      default:              return "<invalid>";
  ------------------
  |  Branch (132:7): [True: 0, False: 65.8k]
  ------------------
  133|  65.8k|    }
  134|  65.8k|  }
_ZN4wabt4Type24EnumIsReferenceWithIndexENS0_4EnumE:
  183|  2.42M|  static bool EnumIsReferenceWithIndex(Enum value) {
  184|  2.42M|    return value == Type::Reference;
  185|  2.42M|  }

_ZN4wabt9WastLexer7IsDigitEi:
   78|  27.2M|  static bool IsDigit(int c) { return IsCharClass(c, CharClass::Digit); }
_ZN4wabt9WastLexer10IsHexDigitEi:
   79|  12.8M|  static bool IsHexDigit(int c) { return IsCharClass(c, CharClass::HexDigit); }
_ZN4wabt9WastLexer9IsKeywordEi:
   80|  23.5M|  static bool IsKeyword(int c) { return IsCharClass(c, CharClass::Keyword); }
_ZN4wabt9WastLexer8IsIdCharEi:
   81|   168M|  static bool IsIdChar(int c) { return IsCharClass(c, CharClass::IdChar); }
_ZN4wabt9WastLexer23NoTrailingReservedCharsEv:
   88|  1.72M|  bool NoTrailingReservedChars() {
   89|  1.72M|    return ReadReservedChars() == ReservedChars::None;
   90|  1.72M|  }

_ZN4wabt16WastParseOptionsC2ERKNS_8FeaturesE:
   34|  23.2k|  WastParseOptions(const Features& features) : features(features) {}
_ZN4wabt10WastParser12ResolveTypesC2EPNSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEE:
   71|  4.56M|      : target_types(target_types) {}
_ZN4wabt10WastParser12ResolveFuncsC2EPNS_4FuncE:
   79|  1.72M|      : target_func(target_func) {}
_ZN4wabt10WastParser13ConsumeIfLparEv:
  144|  1.30k|  void ConsumeIfLpar() { Match(TokenType::Lpar); }

_ZNK4wabt11BindingHash14FindDuplicatesENSt3__18functionIFvRKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEESE_EEE:
   26|   917k|void BindingHash::FindDuplicates(DuplicateCallback callback) const {
   27|   917k|  if (size() > 0) {
  ------------------
  |  Branch (27:7): [True: 8.10k, False: 909k]
  ------------------
   28|  8.10k|    ValueTypeVector duplicates;
   29|  8.10k|    CreateDuplicatesVector(&duplicates);
   30|  8.10k|    SortDuplicatesVectorByLocation(&duplicates);
   31|  8.10k|    CallCallbacks(duplicates, callback);
   32|  8.10k|  }
   33|   917k|}
_ZNK4wabt11BindingHash9FindIndexERKNS_3VarE:
   35|   210k|Index BindingHash::FindIndex(const Var& var) const {
   36|   210k|  if (var.is_name()) {
  ------------------
  |  Branch (36:7): [True: 192k, False: 18.1k]
  ------------------
   37|   192k|    return FindIndex(var.name());
   38|   192k|  }
   39|  18.1k|  return var.index();
   40|   210k|}
_ZNK4wabt11BindingHash22CreateDuplicatesVectorEPNSt3__16vectorIPKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEENS7_ISE_EEEE:
   43|  8.10k|    ValueTypeVector* out_duplicates) const {
   44|       |  // This relies on the fact that in an unordered_multimap, all values with the
   45|       |  // same key are adjacent in iteration order.
   46|  8.10k|  auto first = begin();
   47|  8.10k|  bool is_first = true;
   48|   628k|  for (auto iter = std::next(first); iter != end(); ++iter) {
  ------------------
  |  Branch (48:38): [True: 620k, False: 8.10k]
  ------------------
   49|   620k|    if (first->first == iter->first) {
  ------------------
  |  Branch (49:9): [True: 606k, False: 13.8k]
  ------------------
   50|   606k|      if (is_first) {
  ------------------
  |  Branch (50:11): [True: 14.2k, False: 592k]
  ------------------
   51|  14.2k|        out_duplicates->push_back(&*first);
   52|  14.2k|      }
   53|   606k|      out_duplicates->push_back(&*iter);
   54|   606k|      is_first = false;
   55|   606k|    } else {
   56|  13.8k|      is_first = true;
   57|  13.8k|      first = iter;
   58|  13.8k|    }
   59|   620k|  }
   60|  8.10k|}
_ZNK4wabt11BindingHash30SortDuplicatesVectorByLocationEPNSt3__16vectorIPKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEENS7_ISE_EEEE:
   63|  8.10k|    ValueTypeVector* duplicates) const {
   64|  8.10k|  std::sort(
   65|  8.10k|      duplicates->begin(), duplicates->end(),
   66|  8.10k|      [](const value_type* lhs, const value_type* rhs) -> bool {
   67|  8.10k|        return lhs->second.loc.line < rhs->second.loc.line ||
   68|  8.10k|               (lhs->second.loc.line == rhs->second.loc.line &&
   69|  8.10k|                lhs->second.loc.first_column < rhs->second.loc.first_column);
   70|  8.10k|      });
   71|  8.10k|}
_ZNK4wabt11BindingHash13CallCallbacksERKNSt3__16vectorIPKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEENS7_ISE_EEEENS1_8functionIFvRSD_SK_EEE:
   74|  8.10k|                                DuplicateCallback callback) const {
   75|       |  // Loop through all duplicates in order, and call callback with first
   76|       |  // occurrence.
   77|   629k|  for (auto iter = duplicates.begin(), end = duplicates.end(); iter != end;
  ------------------
  |  Branch (77:64): [True: 620k, False: 8.10k]
  ------------------
   78|   620k|       ++iter) {
   79|   620k|    auto first = std::find_if(duplicates.begin(), duplicates.end(),
   80|   620k|                              [iter](const value_type* x) -> bool {
   81|   620k|                                return x->first == (*iter)->first;
   82|   620k|                              });
   83|   620k|    if (first == iter) {
  ------------------
  |  Branch (83:9): [True: 14.2k, False: 606k]
  ------------------
   84|  14.2k|      continue;
   85|  14.2k|    }
   86|   606k|    assert(first != duplicates.end());
   87|   606k|    callback(**first, **iter);
   88|   606k|  }
   89|  8.10k|}
binding-hash.cc:_ZZNK4wabt11BindingHash30SortDuplicatesVectorByLocationEPNSt3__16vectorIPKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEENS7_ISE_EEEEENK3$_0clESE_SE_:
   66|  9.13M|      [](const value_type* lhs, const value_type* rhs) -> bool {
   67|  9.13M|        return lhs->second.loc.line < rhs->second.loc.line ||
  ------------------
  |  Branch (67:16): [True: 3.42M, False: 5.71M]
  ------------------
   68|  9.13M|               (lhs->second.loc.line == rhs->second.loc.line &&
  ------------------
  |  Branch (68:17): [True: 3.72M, False: 1.99M]
  ------------------
   69|  5.71M|                lhs->second.loc.first_column < rhs->second.loc.first_column);
  ------------------
  |  Branch (69:17): [True: 2.40M, False: 1.31M]
  ------------------
   70|  9.13M|      });
binding-hash.cc:_ZZNK4wabt11BindingHash13CallCallbacksERKNSt3__16vectorIPKNS1_4pairIKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7BindingEEENS7_ISE_EEEENS1_8functionIFvRSD_SK_EEEENK3$_0clESE_:
   80|  5.95M|                              [iter](const value_type* x) -> bool {
   81|  5.95M|                                return x->first == (*iter)->first;
   82|  5.95M|                              });

_ZN4wabt11ExprVisitorC2EPNS0_8DelegateE:
   24|   994k|ExprVisitor::ExprVisitor(Delegate* delegate) : delegate_(delegate) {}
_ZN4wabt11ExprVisitor9VisitExprEPNS_4ExprE:
   26|   343k|Result ExprVisitor::VisitExpr(Expr* root_expr) {
   27|   343k|  state_stack_.clear();
   28|   343k|  expr_stack_.clear();
   29|   343k|  expr_iter_stack_.clear();
   30|   343k|  catch_index_stack_.clear();
   31|       |
   32|   343k|  PushDefault(root_expr);
   33|       |
   34|   928k|  while (!state_stack_.empty()) {
  ------------------
  |  Branch (34:10): [True: 586k, False: 342k]
  ------------------
   35|   586k|    State state = state_stack_.back();
   36|   586k|    auto* expr = expr_stack_.back();
   37|       |
   38|   586k|    switch (state) {
  ------------------
  |  Branch (38:13): [True: 0, False: 586k]
  ------------------
   39|   391k|      case State::Default:
  ------------------
  |  Branch (39:7): [True: 391k, False: 194k]
  ------------------
   40|   391k|        PopDefault();
   41|   391k|        CHECK_RESULT(HandleDefaultState(expr));
  ------------------
  |  |   55|   391k|  do {                              \
  |  |   56|   391k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.38k, False: 390k]
  |  |  ------------------
  |  |   57|  1.38k|      return ::wabt::Result::Error; \
  |  |   58|  1.38k|    }                               \
  |  |   59|   391k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   42|   390k|        break;
   43|       |
   44|   390k|      case State::Block: {
  ------------------
  |  Branch (44:7): [True: 14.3k, False: 571k]
  ------------------
   45|  14.3k|        auto block_expr = cast<BlockExpr>(expr);
   46|  14.3k|        auto& iter = expr_iter_stack_.back();
   47|  14.3k|        if (iter != block_expr->block.exprs.end()) {
  ------------------
  |  Branch (47:13): [True: 6.72k, False: 7.62k]
  ------------------
   48|  6.72k|          PushDefault(&*iter++);
   49|  7.62k|        } else {
   50|  7.62k|          CHECK_RESULT(delegate_->EndBlockExpr(block_expr));
  ------------------
  |  |   55|  7.62k|  do {                              \
  |  |   56|  7.62k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 7.62k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  7.62k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   51|  7.62k|          PopExprlist();
   52|  7.62k|        }
   53|  14.3k|        break;
   54|  14.3k|      }
   55|       |
   56|  14.3k|      case State::IfTrue: {
  ------------------
  |  Branch (56:7): [True: 4.68k, False: 581k]
  ------------------
   57|  4.68k|        auto if_expr = cast<IfExpr>(expr);
   58|  4.68k|        auto& iter = expr_iter_stack_.back();
   59|  4.68k|        if (iter != if_expr->true_.exprs.end()) {
  ------------------
  |  Branch (59:13): [True: 1.02k, False: 3.66k]
  ------------------
   60|  1.02k|          PushDefault(&*iter++);
   61|  3.66k|        } else {
   62|  3.66k|          CHECK_RESULT(delegate_->AfterIfTrueExpr(if_expr));
  ------------------
  |  |   55|  3.66k|  do {                              \
  |  |   56|  3.66k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.66k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.66k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   63|  3.66k|          PopExprlist();
   64|  3.66k|          PushExprlist(State::IfFalse, expr, if_expr->false_);
   65|  3.66k|        }
   66|  4.68k|        break;
   67|  4.68k|      }
   68|       |
   69|  4.68k|      case State::IfFalse: {
  ------------------
  |  Branch (69:7): [True: 4.30k, False: 582k]
  ------------------
   70|  4.30k|        auto if_expr = cast<IfExpr>(expr);
   71|  4.30k|        auto& iter = expr_iter_stack_.back();
   72|  4.30k|        if (iter != if_expr->false_.end()) {
  ------------------
  |  Branch (72:13): [True: 644, False: 3.66k]
  ------------------
   73|    644|          PushDefault(&*iter++);
   74|  3.66k|        } else {
   75|  3.66k|          CHECK_RESULT(delegate_->EndIfExpr(if_expr));
  ------------------
  |  |   55|  3.66k|  do {                              \
  |  |   56|  3.66k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.66k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.66k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   76|  3.66k|          PopExprlist();
   77|  3.66k|        }
   78|  4.30k|        break;
   79|  4.30k|      }
   80|       |
   81|  69.3k|      case State::Loop: {
  ------------------
  |  Branch (81:7): [True: 69.3k, False: 516k]
  ------------------
   82|  69.3k|        auto loop_expr = cast<LoopExpr>(expr);
   83|  69.3k|        auto& iter = expr_iter_stack_.back();
   84|  69.3k|        if (iter != loop_expr->block.exprs.end()) {
  ------------------
  |  Branch (84:13): [True: 19.2k, False: 50.1k]
  ------------------
   85|  19.2k|          PushDefault(&*iter++);
   86|  50.1k|        } else {
   87|  50.1k|          CHECK_RESULT(delegate_->EndLoopExpr(loop_expr));
  ------------------
  |  |   55|  50.1k|  do {                              \
  |  |   56|  50.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 50.1k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   88|  50.1k|          PopExprlist();
   89|  50.1k|        }
   90|  69.3k|        break;
   91|  69.3k|      }
   92|       |
   93|  69.3k|      case State::TryTable: {
  ------------------
  |  Branch (93:7): [True: 4.03k, False: 582k]
  ------------------
   94|  4.03k|        auto try_table_expr = cast<TryTableExpr>(expr);
   95|  4.03k|        auto& iter = expr_iter_stack_.back();
   96|  4.03k|        if (iter != try_table_expr->block.exprs.end()) {
  ------------------
  |  Branch (96:13): [True: 843, False: 3.18k]
  ------------------
   97|    843|          PushDefault(&*iter++);
   98|  3.18k|        } else {
   99|  3.18k|          CHECK_RESULT(delegate_->EndTryTableExpr(try_table_expr));
  ------------------
  |  |   55|  3.18k|  do {                              \
  |  |   56|  3.18k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.18k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.18k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  100|  3.18k|          PopExprlist();
  101|  3.18k|        }
  102|  4.03k|        break;
  103|  4.03k|      }
  104|       |
  105|  57.2k|      case State::Try: {
  ------------------
  |  Branch (105:7): [True: 57.2k, False: 529k]
  ------------------
  106|  57.2k|        auto try_expr = cast<TryExpr>(expr);
  107|  57.2k|        auto& iter = expr_iter_stack_.back();
  108|  57.2k|        if (iter != try_expr->block.exprs.end()) {
  ------------------
  |  Branch (108:13): [True: 455, False: 56.7k]
  ------------------
  109|    455|          PushDefault(&*iter++);
  110|  56.7k|        } else {
  111|  56.7k|          PopExprlist();
  112|  56.7k|          switch (try_expr->kind) {
  ------------------
  |  Branch (112:19): [True: 0, False: 56.7k]
  ------------------
  113|  19.7k|            case TryKind::Catch:
  ------------------
  |  Branch (113:13): [True: 19.7k, False: 37.0k]
  ------------------
  114|  19.7k|              if (!try_expr->catches.empty()) {
  ------------------
  |  Branch (114:19): [True: 19.7k, False: 0]
  ------------------
  115|  19.7k|                Catch& catch_ = try_expr->catches[0];
  116|  19.7k|                CHECK_RESULT(delegate_->OnCatchExpr(try_expr, &catch_));
  ------------------
  |  |   55|  19.7k|  do {                              \
  |  |   56|  19.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 19.7k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  19.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  117|  19.7k|                PushCatch(expr, 0, catch_.exprs);
  118|  19.7k|              } else {
  119|      0|                CHECK_RESULT(delegate_->EndTryExpr(try_expr));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|      0|              }
  121|  19.7k|              break;
  122|  19.7k|            case TryKind::Delegate:
  ------------------
  |  Branch (122:13): [True: 0, False: 56.7k]
  ------------------
  123|      0|              CHECK_RESULT(delegate_->OnDelegateExpr(try_expr));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|      0|              break;
  125|  37.0k|            case TryKind::Plain:
  ------------------
  |  Branch (125:13): [True: 37.0k, False: 19.7k]
  ------------------
  126|  37.0k|              CHECK_RESULT(delegate_->EndTryExpr(try_expr));
  ------------------
  |  |   55|  37.0k|  do {                              \
  |  |   56|  37.0k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 37.0k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  37.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  127|  37.0k|              break;
  128|  56.7k|          }
  129|  56.7k|        }
  130|  57.2k|        break;
  131|  57.2k|      }
  132|       |
  133|  57.2k|      case State::Catch: {
  ------------------
  |  Branch (133:7): [True: 40.7k, False: 545k]
  ------------------
  134|  40.7k|        auto try_expr = cast<TryExpr>(expr);
  135|  40.7k|        Index catch_index = catch_index_stack_.back();
  136|  40.7k|        auto& iter = expr_iter_stack_.back();
  137|  40.7k|        if (iter != try_expr->catches[catch_index].exprs.end()) {
  ------------------
  |  Branch (137:13): [True: 19.2k, False: 21.4k]
  ------------------
  138|  19.2k|          PushDefault(&*iter++);
  139|  21.4k|        } else {
  140|  21.4k|          PopCatch();
  141|  21.4k|          catch_index++;
  142|  21.4k|          if (catch_index < try_expr->catches.size()) {
  ------------------
  |  Branch (142:15): [True: 1.72k, False: 19.7k]
  ------------------
  143|  1.72k|            Catch& catch_ = try_expr->catches[catch_index];
  144|  1.72k|            CHECK_RESULT(delegate_->OnCatchExpr(try_expr, &catch_));
  ------------------
  |  |   55|  1.72k|  do {                              \
  |  |   56|  1.72k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.72k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  145|  1.72k|            PushCatch(expr, catch_index, catch_.exprs);
  146|  19.7k|          } else {
  147|  19.7k|            CHECK_RESULT(delegate_->EndTryExpr(try_expr));
  ------------------
  |  |   55|  19.7k|  do {                              \
  |  |   56|  19.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 19.7k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  19.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|  19.7k|          }
  149|  21.4k|        }
  150|  40.7k|        break;
  151|  40.7k|      }
  152|   586k|    }
  153|   586k|  }
  154|       |
  155|   342k|  return Result::Ok;
  156|   343k|}
_ZN4wabt11ExprVisitor13VisitExprListERNS_14intrusive_listINS_4ExprEEE:
  158|  2.24M|Result ExprVisitor::VisitExprList(ExprList& exprs) {
  159|  2.24M|  for (Expr& expr : exprs)
  ------------------
  |  Branch (159:19): [True: 343k, False: 2.24M]
  ------------------
  160|   343k|    CHECK_RESULT(VisitExpr(&expr));
  ------------------
  |  |   55|   343k|  do {                              \
  |  |   56|   343k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.38k, False: 342k]
  |  |  ------------------
  |  |   57|  1.38k|      return ::wabt::Result::Error; \
  |  |   58|  1.38k|    }                               \
  |  |   59|   343k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  161|  2.24M|  return Result::Ok;
  162|  2.24M|}
_ZN4wabt11ExprVisitor9VisitFuncEPNS_4FuncE:
  164|  1.85M|Result ExprVisitor::VisitFunc(Func* func) {
  165|  1.85M|  return VisitExprList(func->exprs);
  166|  1.85M|}
_ZN4wabt11ExprVisitor18HandleDefaultStateEPNS_4ExprE:
  168|   391k|Result ExprVisitor::HandleDefaultState(Expr* expr) {
  169|   391k|  switch (expr->type()) {
  ------------------
  |  Branch (169:11): [True: 0, False: 391k]
  ------------------
  170|    564|    case ExprType::AtomicLoad:
  ------------------
  |  Branch (170:5): [True: 564, False: 391k]
  ------------------
  171|    564|      CHECK_RESULT(delegate_->OnAtomicLoadExpr(cast<AtomicLoadExpr>(expr)));
  ------------------
  |  |   55|    564|  do {                              \
  |  |   56|    564|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 564]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    564|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  172|    564|      break;
  173|       |
  174|  1.12k|    case ExprType::AtomicStore:
  ------------------
  |  Branch (174:5): [True: 1.12k, False: 390k]
  ------------------
  175|  1.12k|      CHECK_RESULT(delegate_->OnAtomicStoreExpr(cast<AtomicStoreExpr>(expr)));
  ------------------
  |  |   55|  1.12k|  do {                              \
  |  |   56|  1.12k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.12k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.12k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  176|  1.12k|      break;
  177|       |
  178|  1.70k|    case ExprType::AtomicRmw:
  ------------------
  |  Branch (178:5): [True: 1.70k, False: 389k]
  ------------------
  179|  1.70k|      CHECK_RESULT(delegate_->OnAtomicRmwExpr(cast<AtomicRmwExpr>(expr)));
  ------------------
  |  |   55|  1.70k|  do {                              \
  |  |   56|  1.70k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.70k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.70k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  180|  1.70k|      break;
  181|       |
  182|  1.70k|    case ExprType::AtomicRmwCmpxchg:
  ------------------
  |  Branch (182:5): [True: 197, False: 391k]
  ------------------
  183|    197|      CHECK_RESULT(
  ------------------
  |  |   55|    197|  do {                              \
  |  |   56|    197|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 197]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    197|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  184|    197|          delegate_->OnAtomicRmwCmpxchgExpr(cast<AtomicRmwCmpxchgExpr>(expr)));
  185|    197|      break;
  186|       |
  187|    514|    case ExprType::AtomicWait:
  ------------------
  |  Branch (187:5): [True: 514, False: 391k]
  ------------------
  188|    514|      CHECK_RESULT(delegate_->OnAtomicWaitExpr(cast<AtomicWaitExpr>(expr)));
  ------------------
  |  |   55|    514|  do {                              \
  |  |   56|    514|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 514]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    514|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|    514|      break;
  190|       |
  191|    746|    case ExprType::AtomicFence:
  ------------------
  |  Branch (191:5): [True: 746, False: 390k]
  ------------------
  192|    746|      CHECK_RESULT(delegate_->OnAtomicFenceExpr(cast<AtomicFenceExpr>(expr)));
  ------------------
  |  |   55|    746|  do {                              \
  |  |   56|    746|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 746]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    746|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  193|    746|      break;
  194|       |
  195|    746|    case ExprType::AtomicNotify:
  ------------------
  |  Branch (195:5): [True: 666, False: 390k]
  ------------------
  196|    666|      CHECK_RESULT(delegate_->OnAtomicNotifyExpr(cast<AtomicNotifyExpr>(expr)));
  ------------------
  |  |   55|    666|  do {                              \
  |  |   56|    666|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 666]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    666|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  197|    666|      break;
  198|       |
  199|    737|    case ExprType::Binary:
  ------------------
  |  Branch (199:5): [True: 737, False: 390k]
  ------------------
  200|    737|      CHECK_RESULT(delegate_->OnBinaryExpr(cast<BinaryExpr>(expr)));
  ------------------
  |  |   55|    737|  do {                              \
  |  |   56|    737|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 737]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    737|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  201|    737|      break;
  202|       |
  203|  7.82k|    case ExprType::Block: {
  ------------------
  |  Branch (203:5): [True: 7.82k, False: 383k]
  ------------------
  204|  7.82k|      auto block_expr = cast<BlockExpr>(expr);
  205|  7.82k|      CHECK_RESULT(delegate_->BeginBlockExpr(block_expr));
  ------------------
  |  |   55|  7.82k|  do {                              \
  |  |   56|  7.82k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 195, False: 7.62k]
  |  |  ------------------
  |  |   57|    195|      return ::wabt::Result::Error; \
  |  |   58|    195|    }                               \
  |  |   59|  7.82k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  206|  7.62k|      PushExprlist(State::Block, expr, block_expr->block.exprs);
  207|  7.62k|      break;
  208|  7.82k|    }
  209|       |
  210|  7.20k|    case ExprType::Br:
  ------------------
  |  Branch (210:5): [True: 7.20k, False: 384k]
  ------------------
  211|  7.20k|      CHECK_RESULT(delegate_->OnBrExpr(cast<BrExpr>(expr)));
  ------------------
  |  |   55|  7.20k|  do {                              \
  |  |   56|  7.20k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 7.20k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  7.20k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  212|  7.20k|      break;
  213|       |
  214|  7.20k|    case ExprType::BrIf:
  ------------------
  |  Branch (214:5): [True: 555, False: 391k]
  ------------------
  215|    555|      CHECK_RESULT(delegate_->OnBrIfExpr(cast<BrIfExpr>(expr)));
  ------------------
  |  |   55|    555|  do {                              \
  |  |   56|    555|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 555]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    555|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  216|    555|      break;
  217|       |
  218|  1.15k|    case ExprType::BrTable:
  ------------------
  |  Branch (218:5): [True: 1.15k, False: 390k]
  ------------------
  219|  1.15k|      CHECK_RESULT(delegate_->OnBrTableExpr(cast<BrTableExpr>(expr)));
  ------------------
  |  |   55|  1.15k|  do {                              \
  |  |   56|  1.15k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.15k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.15k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  220|  1.15k|      break;
  221|       |
  222|  4.42k|    case ExprType::Call:
  ------------------
  |  Branch (222:5): [True: 4.42k, False: 387k]
  ------------------
  223|  4.42k|      CHECK_RESULT(delegate_->OnCallExpr(cast<CallExpr>(expr)));
  ------------------
  |  |   55|  4.42k|  do {                              \
  |  |   56|  4.42k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 4.42k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  4.42k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  224|  4.42k|      break;
  225|       |
  226|  4.50k|    case ExprType::CallIndirect:
  ------------------
  |  Branch (226:5): [True: 4.50k, False: 387k]
  ------------------
  227|  4.50k|      CHECK_RESULT(delegate_->OnCallIndirectExpr(cast<CallIndirectExpr>(expr)));
  ------------------
  |  |   55|  4.50k|  do {                              \
  |  |   56|  4.50k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 202, False: 4.29k]
  |  |  ------------------
  |  |   57|    202|      return ::wabt::Result::Error; \
  |  |   58|    202|    }                               \
  |  |   59|  4.50k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  228|  4.29k|      break;
  229|       |
  230|  4.29k|    case ExprType::CallRef:
  ------------------
  |  Branch (230:5): [True: 194, False: 391k]
  ------------------
  231|    194|      CHECK_RESULT(delegate_->OnCallRefExpr(cast<CallRefExpr>(expr)));
  ------------------
  |  |   55|    194|  do {                              \
  |  |   56|    194|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 194]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    194|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  232|    194|      break;
  233|       |
  234|  1.74k|    case ExprType::CodeMetadata:
  ------------------
  |  Branch (234:5): [True: 1.74k, False: 389k]
  ------------------
  235|  1.74k|      CHECK_RESULT(delegate_->OnCodeMetadataExpr(cast<CodeMetadataExpr>(expr)));
  ------------------
  |  |   55|  1.74k|  do {                              \
  |  |   56|  1.74k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.74k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  236|  1.74k|      break;
  237|       |
  238|  1.74k|    case ExprType::Compare:
  ------------------
  |  Branch (238:5): [True: 644, False: 390k]
  ------------------
  239|    644|      CHECK_RESULT(delegate_->OnCompareExpr(cast<CompareExpr>(expr)));
  ------------------
  |  |   55|    644|  do {                              \
  |  |   56|    644|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 644]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    644|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  240|    644|      break;
  241|       |
  242|  52.9k|    case ExprType::Const:
  ------------------
  |  Branch (242:5): [True: 52.9k, False: 338k]
  ------------------
  243|  52.9k|      CHECK_RESULT(delegate_->OnConstExpr(cast<ConstExpr>(expr)));
  ------------------
  |  |   55|  52.9k|  do {                              \
  |  |   56|  52.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 52.9k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  52.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  244|  52.9k|      break;
  245|       |
  246|  52.9k|    case ExprType::Convert:
  ------------------
  |  Branch (246:5): [True: 196, False: 391k]
  ------------------
  247|    196|      CHECK_RESULT(delegate_->OnConvertExpr(cast<ConvertExpr>(expr)));
  ------------------
  |  |   55|    196|  do {                              \
  |  |   56|    196|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 196]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    196|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  248|    196|      break;
  249|       |
  250|    312|    case ExprType::Drop:
  ------------------
  |  Branch (250:5): [True: 312, False: 391k]
  ------------------
  251|    312|      CHECK_RESULT(delegate_->OnDropExpr(cast<DropExpr>(expr)));
  ------------------
  |  |   55|    312|  do {                              \
  |  |   56|    312|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 312]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    312|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  252|    312|      break;
  253|       |
  254|  1.77k|    case ExprType::GlobalGet:
  ------------------
  |  Branch (254:5): [True: 1.77k, False: 389k]
  ------------------
  255|  1.77k|      CHECK_RESULT(delegate_->OnGlobalGetExpr(cast<GlobalGetExpr>(expr)));
  ------------------
  |  |   55|  1.77k|  do {                              \
  |  |   56|  1.77k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.77k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.77k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  256|  1.77k|      break;
  257|       |
  258|  1.77k|    case ExprType::GlobalSet:
  ------------------
  |  Branch (258:5): [True: 1.49k, False: 390k]
  ------------------
  259|  1.49k|      CHECK_RESULT(delegate_->OnGlobalSetExpr(cast<GlobalSetExpr>(expr)));
  ------------------
  |  |   55|  1.49k|  do {                              \
  |  |   56|  1.49k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.49k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.49k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  260|  1.49k|      break;
  261|       |
  262|  4.06k|    case ExprType::If: {
  ------------------
  |  Branch (262:5): [True: 4.06k, False: 387k]
  ------------------
  263|  4.06k|      auto if_expr = cast<IfExpr>(expr);
  264|  4.06k|      CHECK_RESULT(delegate_->BeginIfExpr(if_expr));
  ------------------
  |  |   55|  4.06k|  do {                              \
  |  |   56|  4.06k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 403, False: 3.66k]
  |  |  ------------------
  |  |   57|    403|      return ::wabt::Result::Error; \
  |  |   58|    403|    }                               \
  |  |   59|  4.06k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  265|  3.66k|      PushExprlist(State::IfTrue, expr, if_expr->true_.exprs);
  266|  3.66k|      break;
  267|  4.06k|    }
  268|       |
  269|  1.22k|    case ExprType::Load:
  ------------------
  |  Branch (269:5): [True: 1.22k, False: 390k]
  ------------------
  270|  1.22k|      CHECK_RESULT(delegate_->OnLoadExpr(cast<LoadExpr>(expr)));
  ------------------
  |  |   55|  1.22k|  do {                              \
  |  |   56|  1.22k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.22k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.22k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  271|  1.22k|      break;
  272|       |
  273|  1.22k|    case ExprType::LoadSplat:
  ------------------
  |  Branch (273:5): [True: 0, False: 391k]
  ------------------
  274|      0|      CHECK_RESULT(delegate_->OnLoadSplatExpr(cast<LoadSplatExpr>(expr)));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  275|      0|      break;
  276|       |
  277|      0|    case ExprType::LoadZero:
  ------------------
  |  Branch (277:5): [True: 0, False: 391k]
  ------------------
  278|      0|      CHECK_RESULT(delegate_->OnLoadZeroExpr(cast<LoadZeroExpr>(expr)));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  279|      0|      break;
  280|       |
  281|  1.88k|    case ExprType::LocalGet:
  ------------------
  |  Branch (281:5): [True: 1.88k, False: 389k]
  ------------------
  282|  1.88k|      CHECK_RESULT(delegate_->OnLocalGetExpr(cast<LocalGetExpr>(expr)));
  ------------------
  |  |   55|  1.88k|  do {                              \
  |  |   56|  1.88k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.88k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.88k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  283|  1.88k|      break;
  284|       |
  285|  1.89k|    case ExprType::LocalSet:
  ------------------
  |  Branch (285:5): [True: 1.89k, False: 389k]
  ------------------
  286|  1.89k|      CHECK_RESULT(delegate_->OnLocalSetExpr(cast<LocalSetExpr>(expr)));
  ------------------
  |  |   55|  1.89k|  do {                              \
  |  |   56|  1.89k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.89k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.89k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  287|  1.89k|      break;
  288|       |
  289|  1.92k|    case ExprType::LocalTee:
  ------------------
  |  Branch (289:5): [True: 1.92k, False: 389k]
  ------------------
  290|  1.92k|      CHECK_RESULT(delegate_->OnLocalTeeExpr(cast<LocalTeeExpr>(expr)));
  ------------------
  |  |   55|  1.92k|  do {                              \
  |  |   56|  1.92k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.92k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  291|  1.92k|      break;
  292|       |
  293|  50.3k|    case ExprType::Loop: {
  ------------------
  |  Branch (293:5): [True: 50.3k, False: 341k]
  ------------------
  294|  50.3k|      auto loop_expr = cast<LoopExpr>(expr);
  295|  50.3k|      CHECK_RESULT(delegate_->BeginLoopExpr(loop_expr));
  ------------------
  |  |   55|  50.3k|  do {                              \
  |  |   56|  50.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 196, False: 50.1k]
  |  |  ------------------
  |  |   57|    196|      return ::wabt::Result::Error; \
  |  |   58|    196|    }                               \
  |  |   59|  50.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  296|  50.1k|      PushExprlist(State::Loop, expr, loop_expr->block.exprs);
  297|  50.1k|      break;
  298|  50.3k|    }
  299|       |
  300|    534|    case ExprType::MemoryCopy:
  ------------------
  |  Branch (300:5): [True: 534, False: 391k]
  ------------------
  301|    534|      CHECK_RESULT(delegate_->OnMemoryCopyExpr(cast<MemoryCopyExpr>(expr)));
  ------------------
  |  |   55|    534|  do {                              \
  |  |   56|    534|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 534]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    534|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  302|    534|      break;
  303|       |
  304|  1.89k|    case ExprType::DataDrop:
  ------------------
  |  Branch (304:5): [True: 1.89k, False: 389k]
  ------------------
  305|  1.89k|      CHECK_RESULT(delegate_->OnDataDropExpr(cast<DataDropExpr>(expr)));
  ------------------
  |  |   55|  1.89k|  do {                              \
  |  |   56|  1.89k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.89k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.89k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  306|  1.89k|      break;
  307|       |
  308|  1.89k|    case ExprType::MemoryFill:
  ------------------
  |  Branch (308:5): [True: 582, False: 391k]
  ------------------
  309|    582|      CHECK_RESULT(delegate_->OnMemoryFillExpr(cast<MemoryFillExpr>(expr)));
  ------------------
  |  |   55|    582|  do {                              \
  |  |   56|    582|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 582]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    582|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  310|    582|      break;
  311|       |
  312|    582|    case ExprType::MemoryGrow:
  ------------------
  |  Branch (312:5): [True: 520, False: 391k]
  ------------------
  313|    520|      CHECK_RESULT(delegate_->OnMemoryGrowExpr(cast<MemoryGrowExpr>(expr)));
  ------------------
  |  |   55|    520|  do {                              \
  |  |   56|    520|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 520]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    520|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  314|    520|      break;
  315|       |
  316|  1.72k|    case ExprType::MemoryInit:
  ------------------
  |  Branch (316:5): [True: 1.72k, False: 389k]
  ------------------
  317|  1.72k|      CHECK_RESULT(delegate_->OnMemoryInitExpr(cast<MemoryInitExpr>(expr)));
  ------------------
  |  |   55|  1.72k|  do {                              \
  |  |   56|  1.72k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.72k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  318|  1.72k|      break;
  319|       |
  320|  3.06k|    case ExprType::MemorySize:
  ------------------
  |  Branch (320:5): [True: 3.06k, False: 388k]
  ------------------
  321|  3.06k|      CHECK_RESULT(delegate_->OnMemorySizeExpr(cast<MemorySizeExpr>(expr)));
  ------------------
  |  |   55|  3.06k|  do {                              \
  |  |   56|  3.06k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.06k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.06k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  322|  3.06k|      break;
  323|       |
  324|  4.67k|    case ExprType::TableCopy:
  ------------------
  |  Branch (324:5): [True: 4.67k, False: 386k]
  ------------------
  325|  4.67k|      CHECK_RESULT(delegate_->OnTableCopyExpr(cast<TableCopyExpr>(expr)));
  ------------------
  |  |   55|  4.67k|  do {                              \
  |  |   56|  4.67k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 4.67k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  4.67k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  326|  4.67k|      break;
  327|       |
  328|  4.67k|    case ExprType::ElemDrop:
  ------------------
  |  Branch (328:5): [True: 2.41k, False: 389k]
  ------------------
  329|  2.41k|      CHECK_RESULT(delegate_->OnElemDropExpr(cast<ElemDropExpr>(expr)));
  ------------------
  |  |   55|  2.41k|  do {                              \
  |  |   56|  2.41k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.41k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.41k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  330|  2.41k|      break;
  331|       |
  332|  7.90k|    case ExprType::TableInit:
  ------------------
  |  Branch (332:5): [True: 7.90k, False: 383k]
  ------------------
  333|  7.90k|      CHECK_RESULT(delegate_->OnTableInitExpr(cast<TableInitExpr>(expr)));
  ------------------
  |  |   55|  7.90k|  do {                              \
  |  |   56|  7.90k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 7.90k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  7.90k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  334|  7.90k|      break;
  335|       |
  336|  7.90k|    case ExprType::TableGet:
  ------------------
  |  Branch (336:5): [True: 1.76k, False: 389k]
  ------------------
  337|  1.76k|      CHECK_RESULT(delegate_->OnTableGetExpr(cast<TableGetExpr>(expr)));
  ------------------
  |  |   55|  1.76k|  do {                              \
  |  |   56|  1.76k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.76k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.76k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  338|  1.76k|      break;
  339|       |
  340|  2.44k|    case ExprType::TableSet:
  ------------------
  |  Branch (340:5): [True: 2.44k, False: 389k]
  ------------------
  341|  2.44k|      CHECK_RESULT(delegate_->OnTableSetExpr(cast<TableSetExpr>(expr)));
  ------------------
  |  |   55|  2.44k|  do {                              \
  |  |   56|  2.44k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.44k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.44k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  342|  2.44k|      break;
  343|       |
  344|  2.44k|    case ExprType::TableGrow:
  ------------------
  |  Branch (344:5): [True: 1.82k, False: 389k]
  ------------------
  345|  1.82k|      CHECK_RESULT(delegate_->OnTableGrowExpr(cast<TableGrowExpr>(expr)));
  ------------------
  |  |   55|  1.82k|  do {                              \
  |  |   56|  1.82k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.82k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.82k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  346|  1.82k|      break;
  347|       |
  348|  2.46k|    case ExprType::TableSize:
  ------------------
  |  Branch (348:5): [True: 2.46k, False: 389k]
  ------------------
  349|  2.46k|      CHECK_RESULT(delegate_->OnTableSizeExpr(cast<TableSizeExpr>(expr)));
  ------------------
  |  |   55|  2.46k|  do {                              \
  |  |   56|  2.46k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.46k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.46k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  350|  2.46k|      break;
  351|       |
  352|  2.46k|    case ExprType::TableFill:
  ------------------
  |  Branch (352:5): [True: 2.21k, False: 389k]
  ------------------
  353|  2.21k|      CHECK_RESULT(delegate_->OnTableFillExpr(cast<TableFillExpr>(expr)));
  ------------------
  |  |   55|  2.21k|  do {                              \
  |  |   56|  2.21k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.21k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.21k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  354|  2.21k|      break;
  355|       |
  356|  2.21k|    case ExprType::RefFunc:
  ------------------
  |  Branch (356:5): [True: 1.76k, False: 389k]
  ------------------
  357|  1.76k|      CHECK_RESULT(delegate_->OnRefFuncExpr(cast<RefFuncExpr>(expr)));
  ------------------
  |  |   55|  1.76k|  do {                              \
  |  |   56|  1.76k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.76k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.76k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  358|  1.76k|      break;
  359|       |
  360|  1.76k|    case ExprType::RefNull:
  ------------------
  |  Branch (360:5): [True: 194, False: 391k]
  ------------------
  361|    194|      CHECK_RESULT(delegate_->OnRefNullExpr(cast<RefNullExpr>(expr)));
  ------------------
  |  |   55|    194|  do {                              \
  |  |   56|    194|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 194]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    194|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  362|    194|      break;
  363|       |
  364|    706|    case ExprType::RefIsNull:
  ------------------
  |  Branch (364:5): [True: 706, False: 390k]
  ------------------
  365|    706|      CHECK_RESULT(delegate_->OnRefIsNullExpr(cast<RefIsNullExpr>(expr)));
  ------------------
  |  |   55|    706|  do {                              \
  |  |   56|    706|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 706]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    706|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  366|    706|      break;
  367|       |
  368|   125k|    case ExprType::Nop:
  ------------------
  |  Branch (368:5): [True: 125k, False: 266k]
  ------------------
  369|   125k|      CHECK_RESULT(delegate_->OnNopExpr(cast<NopExpr>(expr)));
  ------------------
  |  |   55|   125k|  do {                              \
  |  |   56|   125k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 125k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|   125k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  370|   125k|      break;
  371|       |
  372|   125k|    case ExprType::Rethrow:
  ------------------
  |  Branch (372:5): [True: 520, False: 391k]
  ------------------
  373|    520|      CHECK_RESULT(delegate_->OnRethrowExpr(cast<RethrowExpr>(expr)));
  ------------------
  |  |   55|    520|  do {                              \
  |  |   56|    520|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 520]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    520|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  374|    520|      break;
  375|       |
  376|  1.05k|    case ExprType::Return:
  ------------------
  |  Branch (376:5): [True: 1.05k, False: 390k]
  ------------------
  377|  1.05k|      CHECK_RESULT(delegate_->OnReturnExpr(cast<ReturnExpr>(expr)));
  ------------------
  |  |   55|  1.05k|  do {                              \
  |  |   56|  1.05k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.05k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.05k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  378|  1.05k|      break;
  379|       |
  380|  1.71k|    case ExprType::ReturnCall:
  ------------------
  |  Branch (380:5): [True: 1.71k, False: 389k]
  ------------------
  381|  1.71k|      CHECK_RESULT(delegate_->OnReturnCallExpr(cast<ReturnCallExpr>(expr)));
  ------------------
  |  |   55|  1.71k|  do {                              \
  |  |   56|  1.71k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.71k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  382|  1.71k|      break;
  383|       |
  384|  4.50k|    case ExprType::ReturnCallIndirect:
  ------------------
  |  Branch (384:5): [True: 4.50k, False: 387k]
  ------------------
  385|  4.50k|      CHECK_RESULT(delegate_->OnReturnCallIndirectExpr(
  ------------------
  |  |   55|  4.50k|  do {                              \
  |  |   56|  4.50k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 194, False: 4.31k]
  |  |  ------------------
  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |   58|    194|    }                               \
  |  |   59|  4.50k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  386|  4.50k|          cast<ReturnCallIndirectExpr>(expr)));
  387|  4.31k|      break;
  388|       |
  389|  4.31k|    case ExprType::Select:
  ------------------
  |  Branch (389:5): [True: 208, False: 391k]
  ------------------
  390|    208|      CHECK_RESULT(delegate_->OnSelectExpr(cast<SelectExpr>(expr)));
  ------------------
  |  |   55|    208|  do {                              \
  |  |   56|    208|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 208]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    208|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  391|    208|      break;
  392|       |
  393|    686|    case ExprType::Store:
  ------------------
  |  Branch (393:5): [True: 686, False: 390k]
  ------------------
  394|    686|      CHECK_RESULT(delegate_->OnStoreExpr(cast<StoreExpr>(expr)));
  ------------------
  |  |   55|    686|  do {                              \
  |  |   56|    686|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 686]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    686|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  395|    686|      break;
  396|       |
  397|  3.60k|    case ExprType::Throw:
  ------------------
  |  Branch (397:5): [True: 3.60k, False: 388k]
  ------------------
  398|  3.60k|      CHECK_RESULT(delegate_->OnThrowExpr(cast<ThrowExpr>(expr)));
  ------------------
  |  |   55|  3.60k|  do {                              \
  |  |   56|  3.60k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.60k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  399|  3.60k|      break;
  400|       |
  401|  3.60k|    case ExprType::ThrowRef:
  ------------------
  |  Branch (401:5): [True: 458, False: 391k]
  ------------------
  402|    458|      CHECK_RESULT(delegate_->OnThrowRefExpr(cast<ThrowRefExpr>(expr)));
  ------------------
  |  |   55|    458|  do {                              \
  |  |   56|    458|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 458]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    458|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  403|    458|      break;
  404|       |
  405|  3.18k|    case ExprType::TryTable: {
  ------------------
  |  Branch (405:5): [True: 3.18k, False: 388k]
  ------------------
  406|  3.18k|      auto try_table_expr = cast<TryTableExpr>(expr);
  407|  3.18k|      CHECK_RESULT(delegate_->BeginTryTableExpr(try_table_expr));
  ------------------
  |  |   55|  3.18k|  do {                              \
  |  |   56|  3.18k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.18k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.18k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  408|  3.18k|      PushExprlist(State::TryTable, expr, try_table_expr->block.exprs);
  409|  3.18k|      break;
  410|  3.18k|    }
  411|       |
  412|  56.9k|    case ExprType::Try: {
  ------------------
  |  Branch (412:5): [True: 56.9k, False: 334k]
  ------------------
  413|  56.9k|      auto try_expr = cast<TryExpr>(expr);
  414|  56.9k|      CHECK_RESULT(delegate_->BeginTryExpr(try_expr));
  ------------------
  |  |   55|  56.9k|  do {                              \
  |  |   56|  56.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 197, False: 56.7k]
  |  |  ------------------
  |  |   57|    197|      return ::wabt::Result::Error; \
  |  |   58|    197|    }                               \
  |  |   59|  56.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  415|  56.7k|      PushExprlist(State::Try, expr, try_expr->block.exprs);
  416|  56.7k|      break;
  417|  56.9k|    }
  418|       |
  419|  1.20k|    case ExprType::Unary:
  ------------------
  |  Branch (419:5): [True: 1.20k, False: 390k]
  ------------------
  420|  1.20k|      CHECK_RESULT(delegate_->OnUnaryExpr(cast<UnaryExpr>(expr)));
  ------------------
  |  |   55|  1.20k|  do {                              \
  |  |   56|  1.20k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.20k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.20k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  421|  1.20k|      break;
  422|       |
  423|  1.20k|    case ExprType::Ternary:
  ------------------
  |  Branch (423:5): [True: 658, False: 390k]
  ------------------
  424|    658|      CHECK_RESULT(delegate_->OnTernaryExpr(cast<TernaryExpr>(expr)));
  ------------------
  |  |   55|    658|  do {                              \
  |  |   56|    658|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 658]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    658|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  425|    658|      break;
  426|       |
  427|    658|    case ExprType::SimdLaneOp: {
  ------------------
  |  Branch (427:5): [True: 208, False: 391k]
  ------------------
  428|    208|      CHECK_RESULT(delegate_->OnSimdLaneOpExpr(cast<SimdLaneOpExpr>(expr)));
  ------------------
  |  |   55|    208|  do {                              \
  |  |   56|    208|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 208]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    208|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  429|    208|      break;
  430|    208|    }
  431|       |
  432|    520|    case ExprType::SimdLoadLane: {
  ------------------
  |  Branch (432:5): [True: 520, False: 391k]
  ------------------
  433|    520|      CHECK_RESULT(delegate_->OnSimdLoadLaneExpr(cast<SimdLoadLaneExpr>(expr)));
  ------------------
  |  |   55|    520|  do {                              \
  |  |   56|    520|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 520]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    520|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  434|    520|      break;
  435|    520|    }
  436|       |
  437|    754|    case ExprType::SimdStoreLane: {
  ------------------
  |  Branch (437:5): [True: 754, False: 390k]
  ------------------
  438|    754|      CHECK_RESULT(
  ------------------
  |  |   55|    754|  do {                              \
  |  |   56|    754|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 754]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    754|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  439|    754|          delegate_->OnSimdStoreLaneExpr(cast<SimdStoreLaneExpr>(expr)));
  440|    754|      break;
  441|    754|    }
  442|       |
  443|    754|    case ExprType::SimdShuffleOp: {
  ------------------
  |  Branch (443:5): [True: 454, False: 391k]
  ------------------
  444|    454|      CHECK_RESULT(
  ------------------
  |  |   55|    454|  do {                              \
  |  |   56|    454|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 454]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    454|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  445|    454|          delegate_->OnSimdShuffleOpExpr(cast<SimdShuffleOpExpr>(expr)));
  446|    454|      break;
  447|    454|    }
  448|       |
  449|    454|    case ExprType::Unreachable:
  ------------------
  |  Branch (449:5): [True: 258, False: 391k]
  ------------------
  450|    258|      CHECK_RESULT(delegate_->OnUnreachableExpr(cast<UnreachableExpr>(expr)));
  ------------------
  |  |   55|    258|  do {                              \
  |  |   56|    258|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 258]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    258|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  451|    258|      break;
  452|   391k|  }
  453|       |
  454|   390k|  return Result::Ok;
  455|   391k|}
_ZN4wabt11ExprVisitor11PushDefaultEPNS_4ExprE:
  457|   391k|void ExprVisitor::PushDefault(Expr* expr) {
  458|   391k|  state_stack_.emplace_back(State::Default);
  459|   391k|  expr_stack_.emplace_back(expr);
  460|   391k|}
_ZN4wabt11ExprVisitor10PopDefaultEv:
  462|   391k|void ExprVisitor::PopDefault() {
  463|   391k|  state_stack_.pop_back();
  464|   391k|  expr_stack_.pop_back();
  465|   391k|}
_ZN4wabt11ExprVisitor12PushExprlistENS0_5StateEPNS_4ExprERNS_14intrusive_listIS2_EE:
  467|   125k|void ExprVisitor::PushExprlist(State state, Expr* expr, ExprList& expr_list) {
  468|   125k|  state_stack_.emplace_back(state);
  469|   125k|  expr_stack_.emplace_back(expr);
  470|   125k|  expr_iter_stack_.emplace_back(expr_list.begin());
  471|   125k|}
_ZN4wabt11ExprVisitor11PopExprlistEv:
  473|   125k|void ExprVisitor::PopExprlist() {
  474|   125k|  state_stack_.pop_back();
  475|   125k|  expr_stack_.pop_back();
  476|   125k|  expr_iter_stack_.pop_back();
  477|   125k|}
_ZN4wabt11ExprVisitor9PushCatchEPNS_4ExprEjRNS_14intrusive_listIS1_EE:
  481|  21.4k|                            ExprList& expr_list) {
  482|  21.4k|  state_stack_.emplace_back(State::Catch);
  483|  21.4k|  expr_stack_.emplace_back(expr);
  484|  21.4k|  expr_iter_stack_.emplace_back(expr_list.begin());
  485|  21.4k|  catch_index_stack_.emplace_back(catch_index);
  486|  21.4k|}
_ZN4wabt11ExprVisitor8PopCatchEv:
  488|  21.4k|void ExprVisitor::PopCatch() {
  489|  21.4k|  state_stack_.pop_back();
  490|  21.4k|  expr_stack_.pop_back();
  491|  21.4k|  expr_iter_stack_.pop_back();
  492|  21.4k|  catch_index_stack_.pop_back();
  493|  21.4k|}

_ZNK4wabt13FuncSignatureeqERKS0_:
  109|  2.25M|bool FuncSignature::operator==(const FuncSignature& rhs) const {
  110|  2.25M|  return param_types == rhs.param_types && result_types == rhs.result_types;
  ------------------
  |  Branch (110:10): [True: 1.37M, False: 877k]
  |  Branch (110:44): [True: 1.03M, False: 334k]
  ------------------
  111|  2.25M|}
_ZN4wabt10LocalTypes3SetERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE:
  175|  1.71M|void LocalTypes::Set(const TypeVector& types) {
  176|  1.71M|  decls_.clear();
  177|  1.71M|  if (types.empty()) {
  ------------------
  |  Branch (177:7): [True: 1.71M, False: 4.66k]
  ------------------
  178|  1.71M|    return;
  179|  1.71M|  }
  180|       |
  181|  4.66k|  Type type = types[0];
  182|  4.66k|  Index count = 1;
  183|  26.0k|  for (Index i = 1; i < types.size(); ++i) {
  ------------------
  |  Branch (183:21): [True: 21.3k, False: 4.66k]
  ------------------
  184|  21.3k|    if (types[i] != type) {
  ------------------
  |  Branch (184:9): [True: 11.1k, False: 10.2k]
  ------------------
  185|  11.1k|      decls_.emplace_back(type, count);
  186|  11.1k|      type = types[i];
  187|  11.1k|      count = 1;
  188|  11.1k|    } else {
  189|  10.2k|      ++count;
  190|  10.2k|    }
  191|  21.3k|  }
  192|  4.66k|  decls_.emplace_back(type, count);
  193|  4.66k|}
_ZNK4wabt4Func13GetLocalIndexERKNS_3VarE:
  228|  1.78k|Index Func::GetLocalIndex(const Var& var) const {
  229|  1.78k|  if (var.is_index()) {
  ------------------
  |  Branch (229:7): [True: 0, False: 1.78k]
  ------------------
  230|      0|    return var.index();
  231|      0|  }
  232|  1.78k|  return bindings.FindIndex(var);
  233|  1.78k|}
_ZNK4wabt6Module11GetFuncTypeERKNS_3VarE:
  315|  28.7k|const FuncType* Module::GetFuncType(const Var& var) const {
  316|  28.7k|  return const_cast<Module*>(this)->GetFuncType(var);
  317|  28.7k|}
_ZN4wabt6Module11GetFuncTypeERKNS_3VarE:
  319|  28.7k|FuncType* Module::GetFuncType(const Var& var) {
  320|  28.7k|  Index index = type_bindings.FindIndex(var);
  321|  28.7k|  if (index >= types.size()) {
  ------------------
  |  Branch (321:7): [True: 10.8k, False: 17.9k]
  ------------------
  322|  10.8k|    return nullptr;
  323|  10.8k|  }
  324|  17.9k|  return dyn_cast<FuncType>(types[index]);
  325|  28.7k|}
_ZNK4wabt6Module16GetFuncTypeIndexERKNS_13FuncSignatureE:
  327|  1.04M|Index Module::GetFuncTypeIndex(const FuncSignature& sig) const {
  328|  2.27M|  for (size_t i = 0; i < types.size(); ++i) {
  ------------------
  |  Branch (328:22): [True: 2.27M, False: 5.59k]
  ------------------
  329|  2.27M|    if (auto* func_type = dyn_cast<FuncType>(types[i])) {
  ------------------
  |  Branch (329:15): [True: 2.25M, False: 22.0k]
  ------------------
  330|  2.25M|      if (func_type->sig == sig) {
  ------------------
  |  Branch (330:11): [True: 1.03M, False: 1.21M]
  ------------------
  331|  1.03M|        return i;
  332|  1.03M|      }
  333|  2.25M|    }
  334|  2.27M|  }
  335|  5.59k|  return kInvalidIndex;
  336|  1.04M|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_22DataSegmentModuleFieldENS1_14default_deleteIS3_EEEE:
  346|  59.5k|void Module::AppendField(std::unique_ptr<DataSegmentModuleField> field) {
  347|  59.5k|  DataSegment& data_segment = field->data_segment;
  348|  59.5k|  if (!data_segment.name.empty()) {
  ------------------
  |  Branch (348:7): [True: 2.90k, False: 56.6k]
  ------------------
  349|  2.90k|    data_segment_bindings.emplace(data_segment.name,
  350|  2.90k|                                  Binding(field->loc, data_segments.size()));
  351|  2.90k|  }
  352|  59.5k|  data_segments.push_back(&data_segment);
  353|  59.5k|  fields.push_back(std::move(field));
  354|  59.5k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_22ElemSegmentModuleFieldENS1_14default_deleteIS3_EEEE:
  356|   238k|void Module::AppendField(std::unique_ptr<ElemSegmentModuleField> field) {
  357|   238k|  ElemSegment& elem_segment = field->elem_segment;
  358|   238k|  if (!elem_segment.name.empty()) {
  ------------------
  |  Branch (358:7): [True: 171k, False: 67.1k]
  ------------------
  359|   171k|    elem_segment_bindings.emplace(elem_segment.name,
  360|   171k|                                  Binding(field->loc, elem_segments.size()));
  361|   171k|  }
  362|   238k|  elem_segments.push_back(&elem_segment);
  363|   238k|  fields.push_back(std::move(field));
  364|   238k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_17ExportModuleFieldENS1_14default_deleteIS3_EEEE:
  375|  46.5k|void Module::AppendField(std::unique_ptr<ExportModuleField> field) {
  376|       |  // Exported names are allowed to be empty.
  377|  46.5k|  Export& export_ = field->export_;
  378|  46.5k|  export_bindings.emplace(export_.name, Binding(field->loc, exports.size()));
  379|  46.5k|  exports.push_back(&export_);
  380|  46.5k|  fields.push_back(std::move(field));
  381|  46.5k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_15FuncModuleFieldENS1_14default_deleteIS3_EEEE:
  383|  1.61M|void Module::AppendField(std::unique_ptr<FuncModuleField> field) {
  384|  1.61M|  Func& func = field->func;
  385|  1.61M|  if (!func.name.empty()) {
  ------------------
  |  Branch (385:7): [True: 459k, False: 1.15M]
  ------------------
  386|   459k|    func_bindings.emplace(func.name, Binding(field->loc, funcs.size()));
  387|   459k|  }
  388|  1.61M|  funcs.push_back(&func);
  389|  1.61M|  fields.push_back(std::move(field));
  390|  1.61M|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_15TypeModuleFieldENS1_14default_deleteIS3_EEEE:
  392|   103k|void Module::AppendField(std::unique_ptr<TypeModuleField> field) {
  393|   103k|  TypeEntry& type = *field->type;
  394|   103k|  if (!type.name.empty()) {
  ------------------
  |  Branch (394:7): [True: 1.76k, False: 101k]
  ------------------
  395|  1.76k|    type_bindings.emplace(type.name, Binding(field->loc, types.size()));
  396|  1.76k|  }
  397|   103k|  types.push_back(&type);
  398|   103k|  fields.push_back(std::move(field));
  399|   103k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_17GlobalModuleFieldENS1_14default_deleteIS3_EEEE:
  401|   373k|void Module::AppendField(std::unique_ptr<GlobalModuleField> field) {
  402|   373k|  Global& global = field->global;
  403|   373k|  if (!global.name.empty()) {
  ------------------
  |  Branch (403:7): [True: 18.8k, False: 354k]
  ------------------
  404|  18.8k|    global_bindings.emplace(global.name, Binding(field->loc, globals.size()));
  405|  18.8k|  }
  406|   373k|  globals.push_back(&global);
  407|   373k|  fields.push_back(std::move(field));
  408|   373k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_17ImportModuleFieldENS1_14default_deleteIS3_EEEE:
  410|   181k|void Module::AppendField(std::unique_ptr<ImportModuleField> field) {
  411|   181k|  Import* import = field->import.get();
  412|   181k|  const std::string* name = nullptr;
  413|   181k|  BindingHash* bindings = nullptr;
  414|   181k|  Index index = kInvalidIndex;
  415|       |
  416|   181k|  switch (import->kind()) {
  ------------------
  |  Branch (416:11): [True: 0, False: 181k]
  ------------------
  417|  73.5k|    case ExternalKind::Func: {
  ------------------
  |  Branch (417:5): [True: 73.5k, False: 108k]
  ------------------
  418|  73.5k|      Func& func = cast<FuncImport>(import)->func;
  419|  73.5k|      name = &func.name;
  420|  73.5k|      bindings = &func_bindings;
  421|  73.5k|      index = funcs.size();
  422|  73.5k|      funcs.push_back(&func);
  423|  73.5k|      ++num_func_imports;
  424|  73.5k|      break;
  425|      0|    }
  426|       |
  427|  17.2k|    case ExternalKind::Table: {
  ------------------
  |  Branch (427:5): [True: 17.2k, False: 164k]
  ------------------
  428|  17.2k|      Table& table = cast<TableImport>(import)->table;
  429|  17.2k|      name = &table.name;
  430|  17.2k|      bindings = &table_bindings;
  431|  17.2k|      index = tables.size();
  432|  17.2k|      tables.push_back(&table);
  433|  17.2k|      ++num_table_imports;
  434|  17.2k|      break;
  435|      0|    }
  436|       |
  437|    698|    case ExternalKind::Memory: {
  ------------------
  |  Branch (437:5): [True: 698, False: 181k]
  ------------------
  438|    698|      Memory& memory = cast<MemoryImport>(import)->memory;
  439|    698|      name = &memory.name;
  440|    698|      bindings = &memory_bindings;
  441|    698|      index = memories.size();
  442|    698|      memories.push_back(&memory);
  443|    698|      ++num_memory_imports;
  444|    698|      break;
  445|      0|    }
  446|       |
  447|  26.3k|    case ExternalKind::Global: {
  ------------------
  |  Branch (447:5): [True: 26.3k, False: 155k]
  ------------------
  448|  26.3k|      Global& global = cast<GlobalImport>(import)->global;
  449|  26.3k|      name = &global.name;
  450|  26.3k|      bindings = &global_bindings;
  451|  26.3k|      index = globals.size();
  452|  26.3k|      globals.push_back(&global);
  453|  26.3k|      ++num_global_imports;
  454|  26.3k|      break;
  455|      0|    }
  456|       |
  457|  63.9k|    case ExternalKind::Tag: {
  ------------------
  |  Branch (457:5): [True: 63.9k, False: 117k]
  ------------------
  458|  63.9k|      Tag& tag = cast<TagImport>(import)->tag;
  459|  63.9k|      name = &tag.name;
  460|  63.9k|      bindings = &tag_bindings;
  461|  63.9k|      index = tags.size();
  462|  63.9k|      tags.push_back(&tag);
  463|  63.9k|      ++num_tag_imports;
  464|  63.9k|      break;
  465|      0|    }
  466|   181k|  }
  467|       |
  468|   181k|  assert(name && bindings && index != kInvalidIndex);
  469|   181k|  if (!name->empty()) {
  ------------------
  |  Branch (469:7): [True: 11.5k, False: 170k]
  ------------------
  470|  11.5k|    bindings->emplace(*name, Binding(field->loc, index));
  471|  11.5k|  }
  472|   181k|  imports.push_back(import);
  473|   181k|  fields.push_back(std::move(field));
  474|   181k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_17MemoryModuleFieldENS1_14default_deleteIS3_EEEE:
  476|   533k|void Module::AppendField(std::unique_ptr<MemoryModuleField> field) {
  477|   533k|  Memory& memory = field->memory;
  478|   533k|  if (!memory.name.empty()) {
  ------------------
  |  Branch (478:7): [True: 1.26k, False: 532k]
  ------------------
  479|  1.26k|    memory_bindings.emplace(memory.name, Binding(field->loc, memories.size()));
  480|  1.26k|  }
  481|   533k|  memories.push_back(&memory);
  482|   533k|  fields.push_back(std::move(field));
  483|   533k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_16StartModuleFieldENS1_14default_deleteIS3_EEEE:
  485|     79|void Module::AppendField(std::unique_ptr<StartModuleField> field) {
  486|     79|  starts.push_back(&field->start);
  487|     79|  fields.push_back(std::move(field));
  488|     79|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_16TableModuleFieldENS1_14default_deleteIS3_EEEE:
  490|   103k|void Module::AppendField(std::unique_ptr<TableModuleField> field) {
  491|   103k|  Table& table = field->table;
  492|   103k|  if (!table.name.empty()) {
  ------------------
  |  Branch (492:7): [True: 2.59k, False: 101k]
  ------------------
  493|  2.59k|    table_bindings.emplace(table.name, Binding(field->loc, tables.size()));
  494|  2.59k|  }
  495|   103k|  tables.push_back(&table);
  496|   103k|  fields.push_back(std::move(field));
  497|   103k|}
_ZN4wabt6Module11AppendFieldENSt3__110unique_ptrINS_11ModuleFieldENS1_14default_deleteIS3_EEEE:
  499|  42.4k|void Module::AppendField(std::unique_ptr<ModuleField> field) {
  500|  42.4k|  switch (field->type()) {
  ------------------
  |  Branch (500:11): [True: 0, False: 42.4k]
  ------------------
  501|      0|    case ModuleFieldType::Func:
  ------------------
  |  Branch (501:5): [True: 0, False: 42.4k]
  ------------------
  502|      0|      AppendField(cast<FuncModuleField>(std::move(field)));
  503|      0|      break;
  504|       |
  505|      0|    case ModuleFieldType::Global:
  ------------------
  |  Branch (505:5): [True: 0, False: 42.4k]
  ------------------
  506|      0|      AppendField(cast<GlobalModuleField>(std::move(field)));
  507|      0|      break;
  508|       |
  509|      0|    case ModuleFieldType::Import:
  ------------------
  |  Branch (509:5): [True: 0, False: 42.4k]
  ------------------
  510|      0|      AppendField(cast<ImportModuleField>(std::move(field)));
  511|      0|      break;
  512|       |
  513|  42.4k|    case ModuleFieldType::Export:
  ------------------
  |  Branch (513:5): [True: 42.4k, False: 0]
  ------------------
  514|  42.4k|      AppendField(cast<ExportModuleField>(std::move(field)));
  515|  42.4k|      break;
  516|       |
  517|      0|    case ModuleFieldType::Type:
  ------------------
  |  Branch (517:5): [True: 0, False: 42.4k]
  ------------------
  518|      0|      AppendField(cast<TypeModuleField>(std::move(field)));
  519|      0|      break;
  520|       |
  521|      0|    case ModuleFieldType::Table:
  ------------------
  |  Branch (521:5): [True: 0, False: 42.4k]
  ------------------
  522|      0|      AppendField(cast<TableModuleField>(std::move(field)));
  523|      0|      break;
  524|       |
  525|      0|    case ModuleFieldType::ElemSegment:
  ------------------
  |  Branch (525:5): [True: 0, False: 42.4k]
  ------------------
  526|      0|      AppendField(cast<ElemSegmentModuleField>(std::move(field)));
  527|      0|      break;
  528|       |
  529|      0|    case ModuleFieldType::Memory:
  ------------------
  |  Branch (529:5): [True: 0, False: 42.4k]
  ------------------
  530|      0|      AppendField(cast<MemoryModuleField>(std::move(field)));
  531|      0|      break;
  532|       |
  533|      0|    case ModuleFieldType::DataSegment:
  ------------------
  |  Branch (533:5): [True: 0, False: 42.4k]
  ------------------
  534|      0|      AppendField(cast<DataSegmentModuleField>(std::move(field)));
  535|      0|      break;
  536|       |
  537|      0|    case ModuleFieldType::Start:
  ------------------
  |  Branch (537:5): [True: 0, False: 42.4k]
  ------------------
  538|      0|      AppendField(cast<StartModuleField>(std::move(field)));
  539|      0|      break;
  540|       |
  541|      0|    case ModuleFieldType::Tag:
  ------------------
  |  Branch (541:5): [True: 0, False: 42.4k]
  ------------------
  542|      0|      AppendField(cast<TagModuleField>(std::move(field)));
  543|      0|      break;
  544|  42.4k|  }
  545|  42.4k|}
_ZN4wabt6Module12AppendFieldsEPNS_14intrusive_listINS_11ModuleFieldEEE:
  547|  2.74M|void Module::AppendFields(ModuleFieldList* fields) {
  548|  2.78M|  while (!fields->empty())
  ------------------
  |  Branch (548:10): [True: 42.4k, False: 2.74M]
  ------------------
  549|  42.4k|    AppendField(std::unique_ptr<ModuleField>(fields->extract_front()));
  550|  2.74M|}
_ZN4wabt3VarC2Ev:
  591|  7.06M|Var::Var() : Var(kInvalidIndex, Location()) {}
_ZN4wabt3VarC2EjRKNS_8LocationE:
  594|  8.11M|    : loc(loc), type_(VarType::Index), index_(index) {}
_ZN4wabt3VarC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS_8LocationE:
  597|   887k|    : loc(loc), type_(VarType::Name), name_(name) {}
_ZN4wabt3VarC2EOS0_:
  599|  1.28M|Var::Var(Var&& rhs) : Var() {
  600|  1.28M|  *this = std::move(rhs);
  601|  1.28M|}
_ZN4wabt3VarC2ERKS0_:
  603|  1.04M|Var::Var(const Var& rhs) : Var() {
  604|  1.04M|  *this = rhs;
  605|  1.04M|}
_ZN4wabt3VaraSEOS0_:
  607|  2.78M|Var& Var::operator=(Var&& rhs) {
  608|  2.78M|  loc = rhs.loc;
  609|  2.78M|  if (rhs.is_index()) {
  ------------------
  |  Branch (609:7): [True: 637k, False: 2.15M]
  ------------------
  610|   637k|    set_index(rhs.index_);
  611|  2.15M|  } else {
  612|  2.15M|    set_name(rhs.name_);
  613|  2.15M|  }
  614|  2.78M|  return *this;
  615|  2.78M|}
_ZN4wabt3VaraSERKS0_:
  617|  1.69M|Var& Var::operator=(const Var& rhs) {
  618|  1.69M|  loc = rhs.loc;
  619|  1.69M|  if (rhs.is_index()) {
  ------------------
  |  Branch (619:7): [True: 863k, False: 828k]
  ------------------
  620|   863k|    set_index(rhs.index_);
  621|   863k|  } else {
  622|   828k|    set_name(rhs.name_);
  623|   828k|  }
  624|  1.69M|  return *this;
  625|  1.69M|}
_ZN4wabt3VarD2Ev:
  627|  8.99M|Var::~Var() {
  628|  8.99M|  Destroy();
  629|  8.99M|}
_ZN4wabt3Var9set_indexEj:
  631|  1.51M|void Var::set_index(Index index) {
  632|  1.51M|  Destroy();
  633|  1.51M|  type_ = VarType::Index;
  634|  1.51M|  index_ = index;
  635|  1.51M|}
_ZN4wabt3Var8set_nameEONSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  637|  2.97M|void Var::set_name(std::string&& name) {
  638|  2.97M|  Destroy();
  639|  2.97M|  type_ = VarType::Name;
  640|  2.97M|  Construct(name_, std::move(name));
  641|  2.97M|}
_ZN4wabt3Var8set_nameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  643|  2.97M|void Var::set_name(std::string_view name) {
  644|  2.97M|  set_name(std::string(name));
  645|  2.97M|}
_ZN4wabt3Var7DestroyEv:
  647|  13.4M|void Var::Destroy() {
  648|  13.4M|  if (is_name()) {
  ------------------
  |  Branch (648:7): [True: 3.86M, False: 9.62M]
  ------------------
  649|  3.86M|    Destruct(name_);
  650|  3.86M|  }
  651|  13.4M|}

_ZN4wabt11LexerSourceC2EPKvm:
   24|  23.2k|    : data_(data), size_(size), read_offset_(0) {}

_ZN4wabt13ParseHexdigitEcPj:
  559|  4.88M|Result ParseHexdigit(char c, uint32_t* out) {
  560|  4.88M|  if (static_cast<unsigned int>(c - '0') <= 9) {
  ------------------
  |  Branch (560:7): [True: 847k, False: 4.03M]
  ------------------
  561|   847k|    *out = c - '0';
  562|   847k|    return Result::Ok;
  563|  4.03M|  } else if (static_cast<unsigned int>(c - 'a') < 6) {
  ------------------
  |  Branch (563:14): [True: 3.45M, False: 582k]
  ------------------
  564|  3.45M|    *out = 10 + (c - 'a');
  565|  3.45M|    return Result::Ok;
  566|  3.45M|  } else if (static_cast<unsigned int>(c - 'A') < 6) {
  ------------------
  |  Branch (566:14): [True: 511k, False: 70.6k]
  ------------------
  567|   511k|    *out = 10 + (c - 'A');
  568|   511k|    return Result::Ok;
  569|   511k|  }
  570|  70.6k|  return Result::Error;
  571|  4.88M|}
_ZN4wabt11ParseUint64EPKcS1_Pm:
  573|   796k|Result ParseUint64(const char* s, const char* end, uint64_t* out) {
  574|   796k|  if (s == end) {
  ------------------
  |  Branch (574:7): [True: 0, False: 796k]
  ------------------
  575|      0|    return Result::Error;
  576|      0|  }
  577|   796k|  uint64_t value = 0;
  578|   796k|  if (*s == '0' && s + 1 < end && s[1] == 'x') {
  ------------------
  |  Branch (578:7): [True: 176k, False: 620k]
  |  Branch (578:20): [True: 27.7k, False: 148k]
  |  Branch (578:35): [True: 22.0k, False: 5.67k]
  ------------------
  579|  22.0k|    s += 2;
  580|  22.0k|    if (s == end) {
  ------------------
  |  Branch (580:9): [True: 0, False: 22.0k]
  ------------------
  581|      0|      return Result::Error;
  582|      0|    }
  583|  22.0k|    constexpr uint64_t kMaxDiv16 = UINT64_MAX / 16;
  584|  22.0k|    constexpr uint64_t kMaxMod16 = UINT64_MAX % 16;
  585|   294k|    for (; s < end; ++s) {
  ------------------
  |  Branch (585:12): [True: 276k, False: 18.3k]
  ------------------
  586|   276k|      uint32_t digit;
  587|   276k|      if (*s == '_') {
  ------------------
  |  Branch (587:11): [True: 245, False: 275k]
  ------------------
  588|    245|        continue;
  589|    245|      }
  590|   275k|      CHECK_RESULT(ParseHexdigit(*s, &digit));
  ------------------
  |  |   55|   275k|  do {                              \
  |  |   56|   275k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 337, False: 275k]
  |  |  ------------------
  |  |   57|    337|      return ::wabt::Result::Error; \
  |  |   58|    337|    }                               \
  |  |   59|   275k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  591|       |      // Check for overflow.
  592|   275k|      if (value > kMaxDiv16 || (value == kMaxDiv16 && digit > kMaxMod16)) {
  ------------------
  |  Branch (592:11): [True: 3.40k, False: 272k]
  |  Branch (592:33): [True: 513, False: 271k]
  |  Branch (592:55): [True: 0, False: 513]
  ------------------
  593|  3.40k|        return Result::Error;
  594|  3.40k|      }
  595|   272k|      value = value * 16 + digit;
  596|   272k|    }
  597|   774k|  } else {
  598|   774k|    constexpr uint64_t kMaxDiv10 = UINT64_MAX / 10;
  599|   774k|    constexpr uint64_t kMaxMod10 = UINT64_MAX % 10;
  600|  1.78M|    for (; s < end; ++s) {
  ------------------
  |  Branch (600:12): [True: 1.01M, False: 770k]
  ------------------
  601|  1.01M|      if (*s == '_') {
  ------------------
  |  Branch (601:11): [True: 735, False: 1.01M]
  ------------------
  602|    735|        continue;
  603|    735|      }
  604|  1.01M|      uint32_t digit = (*s - '0');
  605|  1.01M|      if (digit > 9) {
  ------------------
  |  Branch (605:11): [True: 371, False: 1.01M]
  ------------------
  606|    371|        return Result::Error;
  607|    371|      }
  608|       |      // Check for overflow.
  609|  1.01M|      if (value > kMaxDiv10 || (value == kMaxDiv10 && digit > kMaxMod10)) {
  ------------------
  |  Branch (609:11): [True: 1.53k, False: 1.01M]
  |  Branch (609:33): [True: 2.99k, False: 1.00M]
  |  Branch (609:55): [True: 2.75k, False: 246]
  ------------------
  610|  4.28k|        return Result::Error;
  611|  4.28k|      }
  612|  1.00M|      value = value * 10 + digit;
  613|  1.00M|    }
  614|   774k|  }
  615|   788k|  if (s != end) {
  ------------------
  |  Branch (615:7): [True: 0, False: 788k]
  ------------------
  616|      0|    return Result::Error;
  617|      0|  }
  618|   788k|  *out = value;
  619|   788k|  return Result::Ok;
  620|   788k|}
_ZN4wabt10ParseInt64EPKcS1_PmNS_12ParseIntTypeE:
  625|  21.1k|                  ParseIntType parse_type) {
  626|  21.1k|  bool has_sign = false;
  627|  21.1k|  if (*s == '-' || *s == '+') {
  ------------------
  |  Branch (627:7): [True: 3.36k, False: 17.8k]
  |  Branch (627:20): [True: 238, False: 17.5k]
  ------------------
  628|  3.60k|    if (parse_type == ParseIntType::UnsignedOnly) {
  ------------------
  |  Branch (628:9): [True: 1.90k, False: 1.70k]
  ------------------
  629|  1.90k|      return Result::Error;
  630|  1.90k|    }
  631|  1.70k|    if (*s == '-') {
  ------------------
  |  Branch (631:9): [True: 1.46k, False: 238]
  ------------------
  632|  1.46k|      has_sign = true;
  633|  1.46k|    }
  634|  1.70k|    s++;
  635|  1.70k|  }
  636|  19.2k|  uint64_t value = 0;
  637|  19.2k|  Result result = ParseUint64(s, end, &value);
  638|  19.2k|  if (has_sign) {
  ------------------
  |  Branch (638:7): [True: 1.46k, False: 17.8k]
  ------------------
  639|       |    // abs(INT64_MIN) == INT64_MAX + 1.
  640|  1.46k|    if (value > static_cast<uint64_t>(INT64_MAX) + 1) {
  ------------------
  |  Branch (640:9): [True: 244, False: 1.22k]
  ------------------
  641|    244|      return Result::Error;
  642|    244|    }
  643|  1.22k|    value = UINT64_MAX - value + 1;
  644|  1.22k|  }
  645|  19.0k|  *out = value;
  646|  19.0k|  return result;
  647|  19.2k|}
_ZN4wabt9ParseInt8EPKcS1_PhNS_12ParseIntTypeE:
  754|  2.52k|                 ParseIntType parse_type) {
  755|  2.52k|  return ParseInt(s, end, out, parse_type);
  756|  2.52k|}
_ZN4wabt10ParseInt16EPKcS1_PtNS_12ParseIntTypeE:
  761|  4.40k|                  ParseIntType parse_type) {
  762|  4.40k|  return ParseInt(s, end, out, parse_type);
  763|  4.40k|}
_ZN4wabt10ParseInt32EPKcS1_PjNS_12ParseIntTypeE:
  768|  11.7k|                  ParseIntType parse_type) {
  769|  11.7k|  return ParseInt(s, end, out, parse_type);
  770|  11.7k|}
_ZN4wabt10ParseFloatENS_11LiteralTypeEPKcS2_Pj:
  775|   127k|                  uint32_t* out_bits) {
  776|   127k|  return FloatParser<float>::Parse(literal_type, s, end, out_bits);
  777|   127k|}
_ZN4wabt11ParseDoubleENS_11LiteralTypeEPKcS2_Pm:
  782|   183k|                   uint64_t* out_bits) {
  783|   183k|  return FloatParser<double>::Parse(literal_type, s, end, out_bits);
  784|   183k|}
_ZN4wabt8ParseIntIhEENS_6ResultEPKcS3_PT_NS_12ParseIntTypeE:
  721|  2.52k|                ParseIntType parse_type) {
  722|  2.52k|  using S = typename std::make_signed<U>::type;
  723|  2.52k|  uint64_t value;
  724|  2.52k|  bool has_sign = false;
  725|  2.52k|  if (*s == '-' || *s == '+') {
  ------------------
  |  Branch (725:7): [True: 659, False: 1.86k]
  |  Branch (725:20): [True: 194, False: 1.66k]
  ------------------
  726|    853|    if (parse_type == ParseIntType::UnsignedOnly) {
  ------------------
  |  Branch (726:9): [True: 0, False: 853]
  ------------------
  727|      0|      return Result::Error;
  728|      0|    }
  729|    853|    if (*s == '-') {
  ------------------
  |  Branch (729:9): [True: 659, False: 194]
  ------------------
  730|    659|      has_sign = true;
  731|    659|    }
  732|    853|    s++;
  733|    853|  }
  734|  2.52k|  CHECK_RESULT(ParseUint64(s, end, &value));
  ------------------
  |  |   55|  2.52k|  do {                              \
  |  |   56|  2.52k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 232, False: 2.28k]
  |  |  ------------------
  |  |   57|    232|      return ::wabt::Result::Error; \
  |  |   58|    232|    }                               \
  |  |   59|  2.52k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  735|       |
  736|  2.28k|  if (has_sign) {
  ------------------
  |  Branch (736:7): [True: 659, False: 1.63k]
  ------------------
  737|       |    // abs(INTN_MIN) == INTN_MAX + 1.
  738|    659|    if (value > static_cast<uint64_t>(std::numeric_limits<S>::max()) + 1) {
  ------------------
  |  Branch (738:9): [True: 308, False: 351]
  ------------------
  739|    308|      return Result::Error;
  740|    308|    }
  741|    351|    value = std::numeric_limits<U>::max() - value + 1;
  742|  1.63k|  } else {
  743|  1.63k|    if (value > static_cast<uint64_t>(std::numeric_limits<U>::max())) {
  ------------------
  |  Branch (743:9): [True: 336, False: 1.29k]
  ------------------
  744|    336|      return Result::Error;
  745|    336|    }
  746|  1.63k|  }
  747|  1.64k|  *out = static_cast<U>(value);
  748|  1.64k|  return Result::Ok;
  749|  2.28k|}
_ZN4wabt8ParseIntItEENS_6ResultEPKcS3_PT_NS_12ParseIntTypeE:
  721|  4.40k|                ParseIntType parse_type) {
  722|  4.40k|  using S = typename std::make_signed<U>::type;
  723|  4.40k|  uint64_t value;
  724|  4.40k|  bool has_sign = false;
  725|  4.40k|  if (*s == '-' || *s == '+') {
  ------------------
  |  Branch (725:7): [True: 586, False: 3.81k]
  |  Branch (725:20): [True: 415, False: 3.40k]
  ------------------
  726|  1.00k|    if (parse_type == ParseIntType::UnsignedOnly) {
  ------------------
  |  Branch (726:9): [True: 0, False: 1.00k]
  ------------------
  727|      0|      return Result::Error;
  728|      0|    }
  729|  1.00k|    if (*s == '-') {
  ------------------
  |  Branch (729:9): [True: 586, False: 415]
  ------------------
  730|    586|      has_sign = true;
  731|    586|    }
  732|  1.00k|    s++;
  733|  1.00k|  }
  734|  4.40k|  CHECK_RESULT(ParseUint64(s, end, &value));
  ------------------
  |  |   55|  4.40k|  do {                              \
  |  |   56|  4.40k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 794, False: 3.61k]
  |  |  ------------------
  |  |   57|    794|      return ::wabt::Result::Error; \
  |  |   58|    794|    }                               \
  |  |   59|  4.40k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  735|       |
  736|  3.61k|  if (has_sign) {
  ------------------
  |  Branch (736:7): [True: 583, False: 3.02k]
  ------------------
  737|       |    // abs(INTN_MIN) == INTN_MAX + 1.
  738|    583|    if (value > static_cast<uint64_t>(std::numeric_limits<S>::max()) + 1) {
  ------------------
  |  Branch (738:9): [True: 329, False: 254]
  ------------------
  739|    329|      return Result::Error;
  740|    329|    }
  741|    254|    value = std::numeric_limits<U>::max() - value + 1;
  742|  3.02k|  } else {
  743|  3.02k|    if (value > static_cast<uint64_t>(std::numeric_limits<U>::max())) {
  ------------------
  |  Branch (743:9): [True: 787, False: 2.24k]
  ------------------
  744|    787|      return Result::Error;
  745|    787|    }
  746|  3.02k|  }
  747|  2.49k|  *out = static_cast<U>(value);
  748|  2.49k|  return Result::Ok;
  749|  3.61k|}
_ZN4wabt8ParseIntIjEENS_6ResultEPKcS3_PT_NS_12ParseIntTypeE:
  721|  11.7k|                ParseIntType parse_type) {
  722|  11.7k|  using S = typename std::make_signed<U>::type;
  723|  11.7k|  uint64_t value;
  724|  11.7k|  bool has_sign = false;
  725|  11.7k|  if (*s == '-' || *s == '+') {
  ------------------
  |  Branch (725:7): [True: 1.31k, False: 10.3k]
  |  Branch (725:20): [True: 194, False: 10.1k]
  ------------------
  726|  1.50k|    if (parse_type == ParseIntType::UnsignedOnly) {
  ------------------
  |  Branch (726:9): [True: 0, False: 1.50k]
  ------------------
  727|      0|      return Result::Error;
  728|      0|    }
  729|  1.50k|    if (*s == '-') {
  ------------------
  |  Branch (729:9): [True: 1.31k, False: 194]
  ------------------
  730|  1.31k|      has_sign = true;
  731|  1.31k|    }
  732|  1.50k|    s++;
  733|  1.50k|  }
  734|  11.7k|  CHECK_RESULT(ParseUint64(s, end, &value));
  ------------------
  |  |   55|  11.7k|  do {                              \
  |  |   56|  11.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 543, False: 11.1k]
  |  |  ------------------
  |  |   57|    543|      return ::wabt::Result::Error; \
  |  |   58|    543|    }                               \
  |  |   59|  11.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  735|       |
  736|  11.1k|  if (has_sign) {
  ------------------
  |  Branch (736:7): [True: 1.20k, False: 9.95k]
  ------------------
  737|       |    // abs(INTN_MIN) == INTN_MAX + 1.
  738|  1.20k|    if (value > static_cast<uint64_t>(std::numeric_limits<S>::max()) + 1) {
  ------------------
  |  Branch (738:9): [True: 559, False: 643]
  ------------------
  739|    559|      return Result::Error;
  740|    559|    }
  741|    643|    value = std::numeric_limits<U>::max() - value + 1;
  742|  9.95k|  } else {
  743|  9.95k|    if (value > static_cast<uint64_t>(std::numeric_limits<U>::max())) {
  ------------------
  |  Branch (743:9): [True: 7.82k, False: 2.13k]
  ------------------
  744|  7.82k|      return Result::Error;
  745|  7.82k|    }
  746|  9.95k|  }
  747|  2.77k|  *out = static_cast<U>(value);
  748|  2.77k|  return Result::Ok;
  749|  11.1k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE5ParseENS_11LiteralTypeEPKcS5_Pj:
  429|   127k|                             Uint* out_bits) {
  430|       |#if COMPILER_IS_MSVC
  431|       |  if (literal_type == LiteralType::Int && StringStartsWith(s, end, "0x")) {
  432|       |    // Some MSVC crt implementation of strtof doesn't support hex strings
  433|       |    literal_type = LiteralType::Hexfloat;
  434|       |  }
  435|       |#endif
  436|   127k|  switch (literal_type) {
  ------------------
  |  Branch (436:11): [True: 0, False: 127k]
  ------------------
  437|  20.3k|    case LiteralType::Int:
  ------------------
  |  Branch (437:5): [True: 20.3k, False: 106k]
  ------------------
  438|  21.2k|    case LiteralType::Float:
  ------------------
  |  Branch (438:5): [True: 857, False: 126k]
  ------------------
  439|  21.2k|      return ParseFloat(s, end, out_bits);
  440|       |
  441|  54.1k|    case LiteralType::Hexfloat:
  ------------------
  |  Branch (441:5): [True: 54.1k, False: 72.9k]
  ------------------
  442|  54.1k|      return ParseHex(s, end, out_bits);
  443|       |
  444|  44.3k|    case LiteralType::Infinity:
  ------------------
  |  Branch (444:5): [True: 44.3k, False: 82.8k]
  ------------------
  445|  44.3k|      ParseInfinity(s, end, out_bits);
  446|  44.3k|      return Result::Ok;
  447|       |
  448|  7.38k|    case LiteralType::Nan:
  ------------------
  |  Branch (448:5): [True: 7.38k, False: 119k]
  ------------------
  449|  7.38k|      return ParseNan(s, end, out_bits);
  450|   127k|  }
  451|       |
  452|      0|  WABT_UNREACHABLE;
  ------------------
  |  |  112|      0|#define WABT_UNREACHABLE abort()
  ------------------
  453|   127k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE10ParseFloatEPKcS4_Pj:
  137|  21.2k|                                  Uint* out_bits) {
  138|       |  // Here is the normal behavior for strtof/strtod:
  139|       |  //
  140|       |  // input     | errno  |   output   |
  141|       |  // ---------------------------------
  142|       |  // overflow  | ERANGE | +-HUGE_VAL |
  143|       |  // underflow | ERANGE |        0.0 |
  144|       |  // otherwise |      0 |      value |
  145|       |  //
  146|       |  // So normally we need to clear errno before calling strto{f,d}, and check
  147|       |  // afterward whether it was set to ERANGE.
  148|       |  //
  149|       |  // glibc seems to have a bug where
  150|       |  // strtof("340282356779733661637539395458142568448") will return HUGE_VAL,
  151|       |  // but will not set errno to ERANGE. Since this function is only called when
  152|       |  // we know that we have parsed a "normal" number (i.e. not "inf"), we know
  153|       |  // that if we ever get HUGE_VAL, it must be overflow.
  154|       |  //
  155|       |  // The WebAssembly spec also ignores underflow, so we don't need to check for
  156|       |  // ERANGE at all.
  157|       |
  158|       |  // WebAssembly floats can contain underscores, but strto* can't parse those,
  159|       |  // so remove them first.
  160|  21.2k|  assert(s <= end);
  161|  21.2k|  const size_t kBufferSize = end - s + 1;  // +1 for \0.
  162|  21.2k|  char* buffer = static_cast<char*>(alloca(kBufferSize));
  163|  21.2k|  auto buffer_end =
  164|  21.2k|      std::copy_if(s, end, buffer, [](char c) -> bool { return c != '_'; });
  165|  21.2k|  assert(buffer_end < buffer + kBufferSize);
  166|  21.2k|  *buffer_end = 0;
  167|       |
  168|  21.2k|  char* endptr;
  169|  21.2k|  Float value = Traits::Strto(buffer, &endptr);
  170|  21.2k|  if (endptr != buffer_end ||
  ------------------
  |  Branch (170:7): [True: 0, False: 21.2k]
  ------------------
  171|  21.2k|      (value == Traits::kHugeVal || value == -Traits::kHugeVal)) {
  ------------------
  |  Branch (171:8): [True: 370, False: 20.8k]
  |  Branch (171:37): [True: 294, False: 20.5k]
  ------------------
  172|    664|    return Result::Error;
  173|    664|  }
  174|       |
  175|  20.5k|  memcpy(out_bits, &value, sizeof(value));
  176|  20.5k|  return Result::Ok;
  177|  21.2k|}
literal.cc:_ZZN4wabt12_GLOBAL__N_111FloatParserIfE10ParseFloatEPKcS4_PjENKUlcE_clEc:
  164|   179k|      std::copy_if(s, end, buffer, [](char c) -> bool { return c != '_'; });
literal.cc:_ZN4wabt12_GLOBAL__N_115FloatTraitsBaseIfE5StrtoEPKcPPc:
   46|  21.2k|  static float Strto(const char* s, char** endptr) { return strtof(s, endptr); }
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE8ParseHexEPKcS4_Pj:
  255|  54.1k|                                Uint* out_bits) {
  256|  54.1k|  bool is_neg = false;
  257|  54.1k|  if (*s == '-') {
  ------------------
  |  Branch (257:7): [True: 204, False: 53.9k]
  ------------------
  258|    204|    is_neg = true;
  259|    204|    s++;
  260|  53.9k|  } else if (*s == '+') {
  ------------------
  |  Branch (260:14): [True: 220, False: 53.7k]
  ------------------
  261|    220|    s++;
  262|    220|  }
  263|  54.1k|  assert(StringStartsWith(s, end, "0x"));
  264|  54.1k|  s += 2;
  265|       |
  266|       |  // Loop over the significand; everything up to the 'p'.
  267|       |  // This code is a bit nasty because we want to support extra zeroes anywhere
  268|       |  // without having to use many significand bits.
  269|       |  // e.g.
  270|       |  // 0x00000001.0p0 => significand = 1, significand_exponent = 0
  271|       |  // 0x10000000.0p0 => significand = 1, significand_exponent = 28
  272|       |  // 0x0.000001p0 => significand = 1, significand_exponent = -24
  273|  54.1k|  bool seen_dot = false;
  274|  54.1k|  bool seen_trailing_non_zero = false;
  275|  54.1k|  Uint significand = 0;
  276|  54.1k|  int significand_exponent = 0;  // Exponent adjustment due to dot placement.
  277|  1.80M|  for (; s < end; ++s) {
  ------------------
  |  Branch (277:10): [True: 1.79M, False: 11.4k]
  ------------------
  278|  1.79M|    uint32_t digit;
  279|  1.79M|    if (*s == '_') {
  ------------------
  |  Branch (279:9): [True: 27.3k, False: 1.76M]
  ------------------
  280|  27.3k|      continue;
  281|  1.76M|    } else if (*s == '.') {
  ------------------
  |  Branch (281:16): [True: 11.5k, False: 1.75M]
  ------------------
  282|  11.5k|      seen_dot = true;
  283|  1.75M|    } else if (Succeeded(ParseHexdigit(*s, &digit))) {
  ------------------
  |  Branch (283:16): [True: 1.71M, False: 42.7k]
  ------------------
  284|  1.71M|      if (Traits::kBits - Clz(significand) <= Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (284:11): [True: 338k, False: 1.37M]
  ------------------
  285|   338k|        significand = (significand << 4) + digit;
  286|   338k|        if (seen_dot) {
  ------------------
  |  Branch (286:13): [True: 55.2k, False: 283k]
  ------------------
  287|  55.2k|          significand_exponent -= 4;
  288|  55.2k|        }
  289|  1.37M|      } else {
  290|  1.37M|        if (!seen_trailing_non_zero && digit != 0) {
  ------------------
  |  Branch (290:13): [True: 10.6k, False: 1.36M]
  |  Branch (290:40): [True: 1.60k, False: 9.06k]
  ------------------
  291|  1.60k|          seen_trailing_non_zero = true;
  292|  1.60k|        }
  293|  1.37M|        if (!seen_dot) {
  ------------------
  |  Branch (293:13): [True: 1.34M, False: 34.9k]
  ------------------
  294|  1.34M|          significand_exponent += 4;
  295|  1.34M|        }
  296|  1.37M|      }
  297|  1.71M|    } else {
  298|  42.7k|      break;
  299|  42.7k|    }
  300|  1.79M|  }
  301|       |
  302|  54.1k|  if (significand == 0) {
  ------------------
  |  Branch (302:7): [True: 591, False: 53.6k]
  ------------------
  303|       |    // 0 or -0.
  304|    591|    *out_bits = Make(is_neg, Traits::kMinExp, 0);
  305|    591|    return Result::Ok;
  306|    591|  }
  307|       |
  308|  53.6k|  int exponent = 0;
  309|  53.6k|  bool exponent_is_neg = false;
  310|  53.6k|  if (s < end) {
  ------------------
  |  Branch (310:7): [True: 42.5k, False: 11.0k]
  ------------------
  311|  42.5k|    assert(*s == 'p' || *s == 'P');
  312|  42.5k|    s++;
  313|       |    // Exponent is always positive, but significand_exponent is signed.
  314|       |    // significand_exponent_add is negated if exponent will be negative, so it
  315|       |    // can be easily summed to see if the exponent is too large (see below).
  316|  42.5k|    int significand_exponent_add = 0;
  317|  42.5k|    if (*s == '-') {
  ------------------
  |  Branch (317:9): [True: 40.2k, False: 2.27k]
  ------------------
  318|  40.2k|      exponent_is_neg = true;
  319|  40.2k|      significand_exponent_add = -significand_exponent;
  320|  40.2k|      s++;
  321|  40.2k|    } else if (*s == '+') {
  ------------------
  |  Branch (321:16): [True: 231, False: 2.04k]
  ------------------
  322|    231|      s++;
  323|    231|      significand_exponent_add = significand_exponent;
  324|    231|    }
  325|       |
  326|   133k|    for (; s < end; ++s) {
  ------------------
  |  Branch (326:12): [True: 121k, False: 12.5k]
  ------------------
  327|   121k|      if (*s == '_') {
  ------------------
  |  Branch (327:11): [True: 17.2k, False: 104k]
  ------------------
  328|  17.2k|        continue;
  329|  17.2k|      }
  330|       |
  331|   104k|      uint32_t digit = (*s - '0');
  332|   104k|      assert(digit <= 9);
  333|   104k|      exponent = exponent * 10 + digit;
  334|   104k|      if (exponent + significand_exponent_add >= Traits::kMaxExp) {
  ------------------
  |  Branch (334:11): [True: 29.9k, False: 74.1k]
  ------------------
  335|  29.9k|        break;
  336|  29.9k|      }
  337|   104k|    }
  338|  42.5k|  }
  339|       |
  340|  53.6k|  if (exponent_is_neg) {
  ------------------
  |  Branch (340:7): [True: 40.2k, False: 13.3k]
  ------------------
  341|  40.2k|    exponent = -exponent;
  342|  40.2k|  }
  343|       |
  344|  53.6k|  int significand_bits = Traits::kBits - Clz(significand);
  345|       |  // -1 for the implicit 1 bit of the significand.
  346|  53.6k|  exponent += significand_exponent + significand_bits - 1;
  347|       |
  348|  53.6k|  if (exponent <= Traits::kMinExp) {
  ------------------
  |  Branch (348:7): [True: 29.0k, False: 24.5k]
  ------------------
  349|       |    // Maybe subnormal.
  350|  29.0k|    auto update_seen_trailing_non_zero = [&](int shift) {
  351|  29.0k|      assert(shift > 0);
  352|  29.0k|      auto mask = (Uint(1) << (shift - 1)) - 1;
  353|  29.0k|      seen_trailing_non_zero |= (significand & mask) != 0;
  354|  29.0k|    };
  355|       |
  356|       |    // Normalize significand.
  357|  29.0k|    if (significand_bits > Traits::kSigBits) {
  ------------------
  |  Branch (357:9): [True: 19.1k, False: 9.91k]
  ------------------
  358|  19.1k|      int shift = significand_bits - Traits::kSigBits;
  359|  19.1k|      update_seen_trailing_non_zero(shift);
  360|  19.1k|      significand >>= shift;
  361|  19.1k|    } else if (significand_bits < Traits::kSigBits) {
  ------------------
  |  Branch (361:16): [True: 1.12k, False: 8.78k]
  ------------------
  362|  1.12k|      significand <<= (Traits::kSigBits - significand_bits);
  363|  1.12k|    }
  364|       |
  365|  29.0k|    int shift = Traits::kMinExp - exponent;
  366|  29.0k|    if (shift <= Traits::kSigBits) {
  ------------------
  |  Branch (366:9): [True: 18.8k, False: 10.2k]
  ------------------
  367|  18.8k|      if (shift) {
  ------------------
  |  Branch (367:11): [True: 1.45k, False: 17.3k]
  ------------------
  368|  1.45k|        update_seen_trailing_non_zero(shift);
  369|  1.45k|        significand =
  370|  1.45k|            ShiftAndRoundToNearest(significand, shift, seen_trailing_non_zero) &
  371|  1.45k|            Traits::kSigMask;
  372|  1.45k|      }
  373|  18.8k|      exponent = Traits::kMinExp;
  374|       |
  375|  18.8k|      if (significand != 0) {
  ------------------
  |  Branch (375:11): [True: 18.6k, False: 208]
  ------------------
  376|  18.6k|        *out_bits = Make(is_neg, exponent, significand);
  377|  18.6k|        return Result::Ok;
  378|  18.6k|      }
  379|  18.8k|    }
  380|       |
  381|       |    // Not subnormal, too small; return 0 or -0.
  382|  10.4k|    *out_bits = Make(is_neg, Traits::kMinExp, 0);
  383|  24.5k|  } else {
  384|       |    // Maybe Normal value.
  385|  24.5k|    if (significand_bits > Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (385:9): [True: 19.7k, False: 4.81k]
  ------------------
  386|  19.7k|      significand = ShiftAndRoundToNearest(
  387|  19.7k|          significand, significand_bits - Traits::kSigPlusOneBits,
  388|  19.7k|          seen_trailing_non_zero);
  389|  19.7k|      if (significand > Traits::kSigPlusOneMask) {
  ------------------
  |  Branch (389:11): [True: 296, False: 19.4k]
  ------------------
  390|    296|        exponent++;
  391|    296|      }
  392|  19.7k|    } else if (significand_bits < Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (392:16): [True: 4.21k, False: 608]
  ------------------
  393|  4.21k|      significand <<= (Traits::kSigPlusOneBits - significand_bits);
  394|  4.21k|    }
  395|       |
  396|  24.5k|    if (exponent >= Traits::kMaxExp) {
  ------------------
  |  Branch (396:9): [True: 1.42k, False: 23.1k]
  ------------------
  397|       |      // Would be inf or -inf, but the spec doesn't allow rounding hex-floats to
  398|       |      // infinity.
  399|  1.42k|      return Result::Error;
  400|  1.42k|    }
  401|       |
  402|  23.1k|    *out_bits = Make(is_neg, exponent, significand & Traits::kSigMask);
  403|  23.1k|  }
  404|       |
  405|  33.5k|  return Result::Ok;
  406|  53.6k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE16StringStartsWithEPKcS4_S4_:
  122|   112k|                                      const char* prefix) {
  123|   395k|  while (start < end && *prefix) {
  ------------------
  |  Branch (123:10): [True: 350k, False: 45.2k]
  |  Branch (123:25): [True: 283k, False: 67.1k]
  ------------------
  124|   283k|    if (*start != *prefix) {
  ------------------
  |  Branch (124:9): [True: 0, False: 283k]
  ------------------
  125|      0|      return false;
  126|      0|    }
  127|   283k|    start++;
  128|   283k|    prefix++;
  129|   283k|  }
  130|   112k|  return *prefix == 0;
  131|   112k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE4MakeEbij:
  183|   103k|                                                   Uint sig) {
  184|   103k|  assert(exp >= Traits::kMinExp && exp <= Traits::kMaxExp);
  185|   103k|  assert(sig <= Traits::kSigMask);
  186|   103k|  return (Uint(sign) << Traits::kSignShift) |
  187|   103k|         (Uint(exp + Traits::kExpBias) << Traits::kSigBits) | sig;
  188|   103k|}
literal.cc:_ZZN4wabt12_GLOBAL__N_111FloatParserIfE8ParseHexEPKcS4_PjENKUliE_clEi:
  350|  20.5k|    auto update_seen_trailing_non_zero = [&](int shift) {
  351|  20.5k|      assert(shift > 0);
  352|  20.5k|      auto mask = (Uint(1) << (shift - 1)) - 1;
  353|  20.5k|      seen_trailing_non_zero |= (significand & mask) != 0;
  354|  20.5k|    };
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE22ShiftAndRoundToNearestEjib:
  195|  21.1k|    bool seen_trailing_non_zero) {
  196|  21.1k|  assert(shift > 0);
  197|       |  // Round ties to even.
  198|  21.1k|  if ((significand & (Uint(1) << shift)) || seen_trailing_non_zero) {
  ------------------
  |  Branch (198:7): [True: 11.3k, False: 9.82k]
  |  Branch (198:45): [True: 1.66k, False: 8.15k]
  ------------------
  199|  13.0k|    significand += Uint(1) << (shift - 1);
  200|  13.0k|  }
  201|  21.1k|  significand >>= shift;
  202|  21.1k|  return significand;
  203|  21.1k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE13ParseInfinityEPKcS4_Pj:
  412|  44.3k|                                   Uint* out_bits) {
  413|  44.3k|  bool is_neg = false;
  414|  44.3k|  if (*s == '-') {
  ------------------
  |  Branch (414:7): [True: 218, False: 44.1k]
  ------------------
  415|    218|    is_neg = true;
  416|    218|    s++;
  417|  44.1k|  } else if (*s == '+') {
  ------------------
  |  Branch (417:14): [True: 195, False: 43.9k]
  ------------------
  418|    195|    s++;
  419|    195|  }
  420|  44.3k|  assert(StringStartsWith(s, end, "inf"));
  421|  44.3k|  *out_bits = Make(is_neg, Traits::kMaxExp, 0);
  422|  44.3k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIfE8ParseNanEPKcS4_Pj:
  209|  7.38k|                                Uint* out_bits) {
  210|  7.38k|  bool is_neg = false;
  211|  7.38k|  if (*s == '-') {
  ------------------
  |  Branch (211:7): [True: 470, False: 6.91k]
  ------------------
  212|    470|    is_neg = true;
  213|    470|    s++;
  214|  6.91k|  } else if (*s == '+') {
  ------------------
  |  Branch (214:14): [True: 1.96k, False: 4.95k]
  ------------------
  215|  1.96k|    s++;
  216|  1.96k|  }
  217|  7.38k|  assert(StringStartsWith(s, end, "nan"));
  218|  7.38k|  s += 3;
  219|       |
  220|  7.38k|  Uint tag;
  221|  7.38k|  if (s != end) {
  ------------------
  |  Branch (221:7): [True: 6.47k, False: 909]
  ------------------
  222|  6.47k|    tag = 0;
  223|  6.47k|    assert(StringStartsWith(s, end, ":0x"));
  224|  6.47k|    s += 3;
  225|       |
  226|  29.0k|    for (; s < end; ++s) {
  ------------------
  |  Branch (226:12): [True: 23.1k, False: 5.87k]
  ------------------
  227|  23.1k|      if (*s == '_') {
  ------------------
  |  Branch (227:11): [True: 4.39k, False: 18.7k]
  ------------------
  228|  4.39k|        continue;
  229|  4.39k|      }
  230|  18.7k|      uint32_t digit;
  231|  18.7k|      CHECK_RESULT(ParseHexdigit(*s, &digit));
  ------------------
  |  |   55|  18.7k|  do {                              \
  |  |   56|  18.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 18.7k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  18.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  232|  18.7k|      tag = tag * 16 + digit;
  233|       |      // Check for overflow.
  234|  18.7k|      if (tag > Traits::kSigMask) {
  ------------------
  |  Branch (234:11): [True: 604, False: 18.1k]
  ------------------
  235|    604|        return Result::Error;
  236|    604|      }
  237|  18.7k|    }
  238|       |
  239|       |    // NaN cannot have a zero tag, that is reserved for infinity.
  240|  5.87k|    if (tag == 0) {
  ------------------
  |  Branch (240:9): [True: 413, False: 5.46k]
  ------------------
  241|    413|      return Result::Error;
  242|    413|    }
  243|  5.87k|  } else {
  244|    909|    tag = Traits::kQuietNanTag;
  245|    909|  }
  246|       |
  247|  6.37k|  *out_bits = Make(is_neg, Traits::kMaxExp, tag);
  248|  6.37k|  return Result::Ok;
  249|  7.38k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE5ParseENS_11LiteralTypeEPKcS5_Pm:
  429|   183k|                             Uint* out_bits) {
  430|       |#if COMPILER_IS_MSVC
  431|       |  if (literal_type == LiteralType::Int && StringStartsWith(s, end, "0x")) {
  432|       |    // Some MSVC crt implementation of strtof doesn't support hex strings
  433|       |    literal_type = LiteralType::Hexfloat;
  434|       |  }
  435|       |#endif
  436|   183k|  switch (literal_type) {
  ------------------
  |  Branch (436:11): [True: 0, False: 183k]
  ------------------
  437|  6.37k|    case LiteralType::Int:
  ------------------
  |  Branch (437:5): [True: 6.37k, False: 176k]
  ------------------
  438|   108k|    case LiteralType::Float:
  ------------------
  |  Branch (438:5): [True: 101k, False: 81.1k]
  ------------------
  439|   108k|      return ParseFloat(s, end, out_bits);
  440|       |
  441|  56.3k|    case LiteralType::Hexfloat:
  ------------------
  |  Branch (441:5): [True: 56.3k, False: 126k]
  ------------------
  442|  56.3k|      return ParseHex(s, end, out_bits);
  443|       |
  444|  1.29k|    case LiteralType::Infinity:
  ------------------
  |  Branch (444:5): [True: 1.29k, False: 181k]
  ------------------
  445|  1.29k|      ParseInfinity(s, end, out_bits);
  446|  1.29k|      return Result::Ok;
  447|       |
  448|  17.0k|    case LiteralType::Nan:
  ------------------
  |  Branch (448:5): [True: 17.0k, False: 165k]
  ------------------
  449|  17.0k|      return ParseNan(s, end, out_bits);
  450|   183k|  }
  451|       |
  452|      0|  WABT_UNREACHABLE;
  ------------------
  |  |  112|      0|#define WABT_UNREACHABLE abort()
  ------------------
  453|   183k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE10ParseFloatEPKcS4_Pm:
  137|   108k|                                  Uint* out_bits) {
  138|       |  // Here is the normal behavior for strtof/strtod:
  139|       |  //
  140|       |  // input     | errno  |   output   |
  141|       |  // ---------------------------------
  142|       |  // overflow  | ERANGE | +-HUGE_VAL |
  143|       |  // underflow | ERANGE |        0.0 |
  144|       |  // otherwise |      0 |      value |
  145|       |  //
  146|       |  // So normally we need to clear errno before calling strto{f,d}, and check
  147|       |  // afterward whether it was set to ERANGE.
  148|       |  //
  149|       |  // glibc seems to have a bug where
  150|       |  // strtof("340282356779733661637539395458142568448") will return HUGE_VAL,
  151|       |  // but will not set errno to ERANGE. Since this function is only called when
  152|       |  // we know that we have parsed a "normal" number (i.e. not "inf"), we know
  153|       |  // that if we ever get HUGE_VAL, it must be overflow.
  154|       |  //
  155|       |  // The WebAssembly spec also ignores underflow, so we don't need to check for
  156|       |  // ERANGE at all.
  157|       |
  158|       |  // WebAssembly floats can contain underscores, but strto* can't parse those,
  159|       |  // so remove them first.
  160|   108k|  assert(s <= end);
  161|   108k|  const size_t kBufferSize = end - s + 1;  // +1 for \0.
  162|   108k|  char* buffer = static_cast<char*>(alloca(kBufferSize));
  163|   108k|  auto buffer_end =
  164|   108k|      std::copy_if(s, end, buffer, [](char c) -> bool { return c != '_'; });
  165|   108k|  assert(buffer_end < buffer + kBufferSize);
  166|   108k|  *buffer_end = 0;
  167|       |
  168|   108k|  char* endptr;
  169|   108k|  Float value = Traits::Strto(buffer, &endptr);
  170|   108k|  if (endptr != buffer_end ||
  ------------------
  |  Branch (170:7): [True: 0, False: 108k]
  ------------------
  171|   108k|      (value == Traits::kHugeVal || value == -Traits::kHugeVal)) {
  ------------------
  |  Branch (171:8): [True: 996, False: 107k]
  |  Branch (171:37): [True: 8.73k, False: 98.5k]
  ------------------
  172|  9.72k|    return Result::Error;
  173|  9.72k|  }
  174|       |
  175|  98.5k|  memcpy(out_bits, &value, sizeof(value));
  176|  98.5k|  return Result::Ok;
  177|   108k|}
literal.cc:_ZZN4wabt12_GLOBAL__N_111FloatParserIdE10ParseFloatEPKcS4_PmENKUlcE_clEc:
  164|   504k|      std::copy_if(s, end, buffer, [](char c) -> bool { return c != '_'; });
literal.cc:_ZN4wabt12_GLOBAL__N_115FloatTraitsBaseIdE5StrtoEPKcPPc:
   57|   108k|  static double Strto(const char* s, char** endptr) {
   58|   108k|    return strtod(s, endptr);
   59|   108k|  }
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE8ParseHexEPKcS4_Pm:
  255|  56.3k|                                Uint* out_bits) {
  256|  56.3k|  bool is_neg = false;
  257|  56.3k|  if (*s == '-') {
  ------------------
  |  Branch (257:7): [True: 259, False: 56.1k]
  ------------------
  258|    259|    is_neg = true;
  259|    259|    s++;
  260|  56.1k|  } else if (*s == '+') {
  ------------------
  |  Branch (260:14): [True: 1.42k, False: 54.7k]
  ------------------
  261|  1.42k|    s++;
  262|  1.42k|  }
  263|  56.3k|  assert(StringStartsWith(s, end, "0x"));
  264|  56.3k|  s += 2;
  265|       |
  266|       |  // Loop over the significand; everything up to the 'p'.
  267|       |  // This code is a bit nasty because we want to support extra zeroes anywhere
  268|       |  // without having to use many significand bits.
  269|       |  // e.g.
  270|       |  // 0x00000001.0p0 => significand = 1, significand_exponent = 0
  271|       |  // 0x10000000.0p0 => significand = 1, significand_exponent = 28
  272|       |  // 0x0.000001p0 => significand = 1, significand_exponent = -24
  273|  56.3k|  bool seen_dot = false;
  274|  56.3k|  bool seen_trailing_non_zero = false;
  275|  56.3k|  Uint significand = 0;
  276|  56.3k|  int significand_exponent = 0;  // Exponent adjustment due to dot placement.
  277|  2.52M|  for (; s < end; ++s) {
  ------------------
  |  Branch (277:10): [True: 2.49M, False: 28.8k]
  ------------------
  278|  2.49M|    uint32_t digit;
  279|  2.49M|    if (*s == '_') {
  ------------------
  |  Branch (279:9): [True: 411, False: 2.49M]
  ------------------
  280|    411|      continue;
  281|  2.49M|    } else if (*s == '.') {
  ------------------
  |  Branch (281:16): [True: 34.2k, False: 2.46M]
  ------------------
  282|  34.2k|      seen_dot = true;
  283|  2.46M|    } else if (Succeeded(ParseHexdigit(*s, &digit))) {
  ------------------
  |  Branch (283:16): [True: 2.43M, False: 27.5k]
  ------------------
  284|  2.43M|      if (Traits::kBits - Clz(significand) <= Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (284:11): [True: 473k, False: 1.96M]
  ------------------
  285|   473k|        significand = (significand << 4) + digit;
  286|   473k|        if (seen_dot) {
  ------------------
  |  Branch (286:13): [True: 165k, False: 308k]
  ------------------
  287|   165k|          significand_exponent -= 4;
  288|   165k|        }
  289|  1.96M|      } else {
  290|  1.96M|        if (!seen_trailing_non_zero && digit != 0) {
  ------------------
  |  Branch (290:13): [True: 50.4k, False: 1.91M]
  |  Branch (290:40): [True: 7.00k, False: 43.4k]
  ------------------
  291|  7.00k|          seen_trailing_non_zero = true;
  292|  7.00k|        }
  293|  1.96M|        if (!seen_dot) {
  ------------------
  |  Branch (293:13): [True: 1.92M, False: 38.5k]
  ------------------
  294|  1.92M|          significand_exponent += 4;
  295|  1.92M|        }
  296|  1.96M|      }
  297|  2.43M|    } else {
  298|  27.5k|      break;
  299|  27.5k|    }
  300|  2.49M|  }
  301|       |
  302|  56.3k|  if (significand == 0) {
  ------------------
  |  Branch (302:7): [True: 547, False: 55.8k]
  ------------------
  303|       |    // 0 or -0.
  304|    547|    *out_bits = Make(is_neg, Traits::kMinExp, 0);
  305|    547|    return Result::Ok;
  306|    547|  }
  307|       |
  308|  55.8k|  int exponent = 0;
  309|  55.8k|  bool exponent_is_neg = false;
  310|  55.8k|  if (s < end) {
  ------------------
  |  Branch (310:7): [True: 27.3k, False: 28.5k]
  ------------------
  311|  27.3k|    assert(*s == 'p' || *s == 'P');
  312|  27.3k|    s++;
  313|       |    // Exponent is always positive, but significand_exponent is signed.
  314|       |    // significand_exponent_add is negated if exponent will be negative, so it
  315|       |    // can be easily summed to see if the exponent is too large (see below).
  316|  27.3k|    int significand_exponent_add = 0;
  317|  27.3k|    if (*s == '-') {
  ------------------
  |  Branch (317:9): [True: 25.5k, False: 1.78k]
  ------------------
  318|  25.5k|      exponent_is_neg = true;
  319|  25.5k|      significand_exponent_add = -significand_exponent;
  320|  25.5k|      s++;
  321|  25.5k|    } else if (*s == '+') {
  ------------------
  |  Branch (321:16): [True: 215, False: 1.56k]
  ------------------
  322|    215|      s++;
  323|    215|      significand_exponent_add = significand_exponent;
  324|    215|    }
  325|       |
  326|   106k|    for (; s < end; ++s) {
  ------------------
  |  Branch (326:12): [True: 103k, False: 2.74k]
  ------------------
  327|   103k|      if (*s == '_') {
  ------------------
  |  Branch (327:11): [True: 249, False: 103k]
  ------------------
  328|    249|        continue;
  329|    249|      }
  330|       |
  331|   103k|      uint32_t digit = (*s - '0');
  332|   103k|      assert(digit <= 9);
  333|   103k|      exponent = exponent * 10 + digit;
  334|   103k|      if (exponent + significand_exponent_add >= Traits::kMaxExp) {
  ------------------
  |  Branch (334:11): [True: 24.5k, False: 78.9k]
  ------------------
  335|  24.5k|        break;
  336|  24.5k|      }
  337|   103k|    }
  338|  27.3k|  }
  339|       |
  340|  55.8k|  if (exponent_is_neg) {
  ------------------
  |  Branch (340:7): [True: 25.5k, False: 30.2k]
  ------------------
  341|  25.5k|    exponent = -exponent;
  342|  25.5k|  }
  343|       |
  344|  55.8k|  int significand_bits = Traits::kBits - Clz(significand);
  345|       |  // -1 for the implicit 1 bit of the significand.
  346|  55.8k|  exponent += significand_exponent + significand_bits - 1;
  347|       |
  348|  55.8k|  if (exponent <= Traits::kMinExp) {
  ------------------
  |  Branch (348:7): [True: 24.3k, False: 31.4k]
  ------------------
  349|       |    // Maybe subnormal.
  350|  24.3k|    auto update_seen_trailing_non_zero = [&](int shift) {
  351|  24.3k|      assert(shift > 0);
  352|  24.3k|      auto mask = (Uint(1) << (shift - 1)) - 1;
  353|  24.3k|      seen_trailing_non_zero |= (significand & mask) != 0;
  354|  24.3k|    };
  355|       |
  356|       |    // Normalize significand.
  357|  24.3k|    if (significand_bits > Traits::kSigBits) {
  ------------------
  |  Branch (357:9): [True: 5.40k, False: 18.9k]
  ------------------
  358|  5.40k|      int shift = significand_bits - Traits::kSigBits;
  359|  5.40k|      update_seen_trailing_non_zero(shift);
  360|  5.40k|      significand >>= shift;
  361|  18.9k|    } else if (significand_bits < Traits::kSigBits) {
  ------------------
  |  Branch (361:16): [True: 18.4k, False: 448]
  ------------------
  362|  18.4k|      significand <<= (Traits::kSigBits - significand_bits);
  363|  18.4k|    }
  364|       |
  365|  24.3k|    int shift = Traits::kMinExp - exponent;
  366|  24.3k|    if (shift <= Traits::kSigBits) {
  ------------------
  |  Branch (366:9): [True: 23.9k, False: 425]
  ------------------
  367|  23.9k|      if (shift) {
  ------------------
  |  Branch (367:11): [True: 19.6k, False: 4.25k]
  ------------------
  368|  19.6k|        update_seen_trailing_non_zero(shift);
  369|  19.6k|        significand =
  370|  19.6k|            ShiftAndRoundToNearest(significand, shift, seen_trailing_non_zero) &
  371|  19.6k|            Traits::kSigMask;
  372|  19.6k|      }
  373|  23.9k|      exponent = Traits::kMinExp;
  374|       |
  375|  23.9k|      if (significand != 0) {
  ------------------
  |  Branch (375:11): [True: 23.7k, False: 195]
  ------------------
  376|  23.7k|        *out_bits = Make(is_neg, exponent, significand);
  377|  23.7k|        return Result::Ok;
  378|  23.7k|      }
  379|  23.9k|    }
  380|       |
  381|       |    // Not subnormal, too small; return 0 or -0.
  382|    620|    *out_bits = Make(is_neg, Traits::kMinExp, 0);
  383|  31.4k|  } else {
  384|       |    // Maybe Normal value.
  385|  31.4k|    if (significand_bits > Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (385:9): [True: 21.4k, False: 10.0k]
  ------------------
  386|  21.4k|      significand = ShiftAndRoundToNearest(
  387|  21.4k|          significand, significand_bits - Traits::kSigPlusOneBits,
  388|  21.4k|          seen_trailing_non_zero);
  389|  21.4k|      if (significand > Traits::kSigPlusOneMask) {
  ------------------
  |  Branch (389:11): [True: 574, False: 20.8k]
  ------------------
  390|    574|        exponent++;
  391|    574|      }
  392|  21.4k|    } else if (significand_bits < Traits::kSigPlusOneBits) {
  ------------------
  |  Branch (392:16): [True: 9.85k, False: 194]
  ------------------
  393|  9.85k|      significand <<= (Traits::kSigPlusOneBits - significand_bits);
  394|  9.85k|    }
  395|       |
  396|  31.4k|    if (exponent >= Traits::kMaxExp) {
  ------------------
  |  Branch (396:9): [True: 227, False: 31.2k]
  ------------------
  397|       |      // Would be inf or -inf, but the spec doesn't allow rounding hex-floats to
  398|       |      // infinity.
  399|    227|      return Result::Error;
  400|    227|    }
  401|       |
  402|  31.2k|    *out_bits = Make(is_neg, exponent, significand & Traits::kSigMask);
  403|  31.2k|  }
  404|       |
  405|  31.8k|  return Result::Ok;
  406|  55.8k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE16StringStartsWithEPKcS4_S4_:
  122|  77.0k|                                      const char* prefix) {
  123|   251k|  while (start < end && *prefix) {
  ------------------
  |  Branch (123:10): [True: 235k, False: 16.0k]
  |  Branch (123:25): [True: 174k, False: 60.9k]
  ------------------
  124|   174k|    if (*start != *prefix) {
  ------------------
  |  Branch (124:9): [True: 0, False: 174k]
  ------------------
  125|      0|      return false;
  126|      0|    }
  127|   174k|    start++;
  128|   174k|    prefix++;
  129|   174k|  }
  130|  77.0k|  return *prefix == 0;
  131|  77.0k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE4MakeEbim:
  183|  73.0k|                                                   Uint sig) {
  184|  73.0k|  assert(exp >= Traits::kMinExp && exp <= Traits::kMaxExp);
  185|  73.0k|  assert(sig <= Traits::kSigMask);
  186|  73.0k|  return (Uint(sign) << Traits::kSignShift) |
  187|  73.0k|         (Uint(exp + Traits::kExpBias) << Traits::kSigBits) | sig;
  188|  73.0k|}
literal.cc:_ZZN4wabt12_GLOBAL__N_111FloatParserIdE8ParseHexEPKcS4_PmENKUliE_clEi:
  350|  25.0k|    auto update_seen_trailing_non_zero = [&](int shift) {
  351|  25.0k|      assert(shift > 0);
  352|  25.0k|      auto mask = (Uint(1) << (shift - 1)) - 1;
  353|  25.0k|      seen_trailing_non_zero |= (significand & mask) != 0;
  354|  25.0k|    };
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE22ShiftAndRoundToNearestEmib:
  195|  41.1k|    bool seen_trailing_non_zero) {
  196|  41.1k|  assert(shift > 0);
  197|       |  // Round ties to even.
  198|  41.1k|  if ((significand & (Uint(1) << shift)) || seen_trailing_non_zero) {
  ------------------
  |  Branch (198:7): [True: 1.59k, False: 39.5k]
  |  Branch (198:45): [True: 19.2k, False: 20.3k]
  ------------------
  199|  20.8k|    significand += Uint(1) << (shift - 1);
  200|  20.8k|  }
  201|  41.1k|  significand >>= shift;
  202|  41.1k|  return significand;
  203|  41.1k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE13ParseInfinityEPKcS4_Pm:
  412|  1.29k|                                   Uint* out_bits) {
  413|  1.29k|  bool is_neg = false;
  414|  1.29k|  if (*s == '-') {
  ------------------
  |  Branch (414:7): [True: 202, False: 1.08k]
  ------------------
  415|    202|    is_neg = true;
  416|    202|    s++;
  417|  1.08k|  } else if (*s == '+') {
  ------------------
  |  Branch (417:14): [True: 203, False: 886]
  ------------------
  418|    203|    s++;
  419|    203|  }
  420|  1.29k|  assert(StringStartsWith(s, end, "inf"));
  421|  1.29k|  *out_bits = Make(is_neg, Traits::kMaxExp, 0);
  422|  1.29k|}
literal.cc:_ZN4wabt12_GLOBAL__N_111FloatParserIdE8ParseNanEPKcS4_Pm:
  209|  17.0k|                                Uint* out_bits) {
  210|  17.0k|  bool is_neg = false;
  211|  17.0k|  if (*s == '-') {
  ------------------
  |  Branch (211:7): [True: 469, False: 16.6k]
  ------------------
  212|    469|    is_neg = true;
  213|    469|    s++;
  214|  16.6k|  } else if (*s == '+') {
  ------------------
  |  Branch (214:14): [True: 5.23k, False: 11.3k]
  ------------------
  215|  5.23k|    s++;
  216|  5.23k|  }
  217|  17.0k|  assert(StringStartsWith(s, end, "nan"));
  218|  17.0k|  s += 3;
  219|       |
  220|  17.0k|  Uint tag;
  221|  17.0k|  if (s != end) {
  ------------------
  |  Branch (221:7): [True: 2.29k, False: 14.7k]
  ------------------
  222|  2.29k|    tag = 0;
  223|  2.29k|    assert(StringStartsWith(s, end, ":0x"));
  224|  2.29k|    s += 3;
  225|       |
  226|  21.6k|    for (; s < end; ++s) {
  ------------------
  |  Branch (226:12): [True: 20.5k, False: 1.08k]
  ------------------
  227|  20.5k|      if (*s == '_') {
  ------------------
  |  Branch (227:11): [True: 295, False: 20.2k]
  ------------------
  228|    295|        continue;
  229|    295|      }
  230|  20.2k|      uint32_t digit;
  231|  20.2k|      CHECK_RESULT(ParseHexdigit(*s, &digit));
  ------------------
  |  |   55|  20.2k|  do {                              \
  |  |   56|  20.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 20.2k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  232|  20.2k|      tag = tag * 16 + digit;
  233|       |      // Check for overflow.
  234|  20.2k|      if (tag > Traits::kSigMask) {
  ------------------
  |  Branch (234:11): [True: 1.21k, False: 19.0k]
  ------------------
  235|  1.21k|        return Result::Error;
  236|  1.21k|      }
  237|  20.2k|    }
  238|       |
  239|       |    // NaN cannot have a zero tag, that is reserved for infinity.
  240|  1.08k|    if (tag == 0) {
  ------------------
  |  Branch (240:9): [True: 315, False: 765]
  ------------------
  241|    315|      return Result::Error;
  242|    315|    }
  243|  14.7k|  } else {
  244|  14.7k|    tag = Traits::kQuietNanTag;
  245|  14.7k|  }
  246|       |
  247|  15.5k|  *out_bits = Make(is_neg, Traits::kMaxExp, tag);
  248|  15.5k|  return Result::Ok;
  249|  17.0k|}

_ZNK4wabt6Opcode7GetInfoEv:
   41|   163k|Opcode::Info Opcode::GetInfo() const {
   42|   163k|  if (enum_ < Invalid) {
  ------------------
  |  Branch (42:7): [True: 163k, False: 0]
  ------------------
   43|   163k|    return infos_[enum_];
   44|   163k|  }
   45|       |
   46|      0|  Info invalid_info = infos_[Opcode::Invalid];
   47|      0|  DecodeInvalidOpcode(enum_, &invalid_info.prefix, &invalid_info.code);
   48|      0|  invalid_info.prefix_code = PrefixCode(invalid_info.prefix, invalid_info.code);
   49|      0|  return invalid_info;
   50|   163k|}
_ZNK4wabt6Opcode9IsEnabledERKNS_8FeaturesE:
   64|   294k|bool Opcode::IsEnabled(const Features& features) const {
   65|   294k|  switch (enum_) {
   66|  79.1k|    case Opcode::Try:
  ------------------
  |  Branch (66:5): [True: 79.1k, False: 215k]
  ------------------
   67|  79.1k|    case Opcode::Catch:
  ------------------
  |  Branch (67:5): [True: 0, False: 294k]
  ------------------
   68|  79.1k|    case Opcode::Delegate:
  ------------------
  |  Branch (68:5): [True: 0, False: 294k]
  ------------------
   69|  83.7k|    case Opcode::Throw:
  ------------------
  |  Branch (69:5): [True: 4.60k, False: 289k]
  ------------------
   70|  84.3k|    case Opcode::ThrowRef:
  ------------------
  |  Branch (70:5): [True: 581, False: 293k]
  ------------------
   71|  91.9k|    case Opcode::TryTable:
  ------------------
  |  Branch (71:5): [True: 7.59k, False: 286k]
  ------------------
   72|  92.7k|    case Opcode::Rethrow:
  ------------------
  |  Branch (72:5): [True: 743, False: 293k]
  ------------------
   73|  92.7k|      return features.exceptions_enabled();
   74|       |
   75|  3.74k|    case Opcode::ReturnCallIndirect:
  ------------------
  |  Branch (75:5): [True: 3.74k, False: 290k]
  ------------------
   76|  5.02k|    case Opcode::ReturnCall:
  ------------------
  |  Branch (76:5): [True: 1.28k, False: 293k]
  ------------------
   77|  5.02k|      return features.tail_call_enabled();
   78|       |
   79|    230|    case Opcode::I32TruncSatF32S:
  ------------------
  |  Branch (79:5): [True: 230, False: 294k]
  ------------------
   80|    429|    case Opcode::I32TruncSatF32U:
  ------------------
  |  Branch (80:5): [True: 199, False: 294k]
  ------------------
   81|    624|    case Opcode::I32TruncSatF64S:
  ------------------
  |  Branch (81:5): [True: 195, False: 294k]
  ------------------
   82|    824|    case Opcode::I32TruncSatF64U:
  ------------------
  |  Branch (82:5): [True: 200, False: 294k]
  ------------------
   83|  1.02k|    case Opcode::I64TruncSatF32S:
  ------------------
  |  Branch (83:5): [True: 196, False: 294k]
  ------------------
   84|  1.21k|    case Opcode::I64TruncSatF32U:
  ------------------
  |  Branch (84:5): [True: 194, False: 294k]
  ------------------
   85|  1.40k|    case Opcode::I64TruncSatF64S:
  ------------------
  |  Branch (85:5): [True: 194, False: 294k]
  ------------------
   86|  1.60k|    case Opcode::I64TruncSatF64U:
  ------------------
  |  Branch (86:5): [True: 194, False: 294k]
  ------------------
   87|  1.60k|      return features.sat_float_to_int_enabled();
   88|       |
   89|    338|    case Opcode::I32Extend8S:
  ------------------
  |  Branch (89:5): [True: 338, False: 294k]
  ------------------
   90|  4.96k|    case Opcode::I32Extend16S:
  ------------------
  |  Branch (90:5): [True: 4.62k, False: 289k]
  ------------------
   91|  5.16k|    case Opcode::I64Extend8S:
  ------------------
  |  Branch (91:5): [True: 194, False: 294k]
  ------------------
   92|  5.35k|    case Opcode::I64Extend16S:
  ------------------
  |  Branch (92:5): [True: 197, False: 294k]
  ------------------
   93|  5.55k|    case Opcode::I64Extend32S:
  ------------------
  |  Branch (93:5): [True: 194, False: 294k]
  ------------------
   94|  5.55k|      return features.sign_extension_enabled();
   95|       |
   96|    611|    case Opcode::MemoryAtomicNotify:
  ------------------
  |  Branch (96:5): [True: 611, False: 293k]
  ------------------
   97|  1.02k|    case Opcode::MemoryAtomicWait32:
  ------------------
  |  Branch (97:5): [True: 409, False: 294k]
  ------------------
   98|  1.65k|    case Opcode::MemoryAtomicWait64:
  ------------------
  |  Branch (98:5): [True: 635, False: 293k]
  ------------------
   99|  2.15k|    case Opcode::AtomicFence:
  ------------------
  |  Branch (99:5): [True: 500, False: 293k]
  ------------------
  100|  2.45k|    case Opcode::I32AtomicLoad:
  ------------------
  |  Branch (100:5): [True: 296, False: 294k]
  ------------------
  101|  2.86k|    case Opcode::I64AtomicLoad:
  ------------------
  |  Branch (101:5): [True: 414, False: 294k]
  ------------------
  102|  3.06k|    case Opcode::I32AtomicLoad8U:
  ------------------
  |  Branch (102:5): [True: 196, False: 294k]
  ------------------
  103|  3.25k|    case Opcode::I32AtomicLoad16U:
  ------------------
  |  Branch (103:5): [True: 198, False: 294k]
  ------------------
  104|  3.58k|    case Opcode::I64AtomicLoad8U:
  ------------------
  |  Branch (104:5): [True: 324, False: 294k]
  ------------------
  105|  3.77k|    case Opcode::I64AtomicLoad16U:
  ------------------
  |  Branch (105:5): [True: 194, False: 294k]
  ------------------
  106|  4.23k|    case Opcode::I64AtomicLoad32U:
  ------------------
  |  Branch (106:5): [True: 454, False: 293k]
  ------------------
  107|  16.1k|    case Opcode::I32AtomicStore:
  ------------------
  |  Branch (107:5): [True: 11.8k, False: 282k]
  ------------------
  108|  16.4k|    case Opcode::I64AtomicStore:
  ------------------
  |  Branch (108:5): [True: 346, False: 294k]
  ------------------
  109|  16.6k|    case Opcode::I32AtomicStore8:
  ------------------
  |  Branch (109:5): [True: 199, False: 294k]
  ------------------
  110|  16.8k|    case Opcode::I32AtomicStore16:
  ------------------
  |  Branch (110:5): [True: 198, False: 294k]
  ------------------
  111|  17.1k|    case Opcode::I64AtomicStore8:
  ------------------
  |  Branch (111:5): [True: 301, False: 294k]
  ------------------
  112|  17.3k|    case Opcode::I64AtomicStore16:
  ------------------
  |  Branch (112:5): [True: 194, False: 294k]
  ------------------
  113|  17.5k|    case Opcode::I64AtomicStore32:
  ------------------
  |  Branch (113:5): [True: 194, False: 294k]
  ------------------
  114|  17.8k|    case Opcode::I32AtomicRmwAdd:
  ------------------
  |  Branch (114:5): [True: 304, False: 294k]
  ------------------
  115|  18.0k|    case Opcode::I64AtomicRmwAdd:
  ------------------
  |  Branch (115:5): [True: 195, False: 294k]
  ------------------
  116|  18.2k|    case Opcode::I32AtomicRmw8AddU:
  ------------------
  |  Branch (116:5): [True: 201, False: 294k]
  ------------------
  117|  18.4k|    case Opcode::I32AtomicRmw16AddU:
  ------------------
  |  Branch (117:5): [True: 205, False: 294k]
  ------------------
  118|  18.6k|    case Opcode::I64AtomicRmw8AddU:
  ------------------
  |  Branch (118:5): [True: 195, False: 294k]
  ------------------
  119|  24.3k|    case Opcode::I64AtomicRmw16AddU:
  ------------------
  |  Branch (119:5): [True: 5.71k, False: 288k]
  ------------------
  120|  24.5k|    case Opcode::I64AtomicRmw32AddU:
  ------------------
  |  Branch (120:5): [True: 214, False: 294k]
  ------------------
  121|  24.8k|    case Opcode::I32AtomicRmwSub:
  ------------------
  |  Branch (121:5): [True: 274, False: 294k]
  ------------------
  122|  25.0k|    case Opcode::I64AtomicRmwSub:
  ------------------
  |  Branch (122:5): [True: 200, False: 294k]
  ------------------
  123|  25.2k|    case Opcode::I32AtomicRmw8SubU:
  ------------------
  |  Branch (123:5): [True: 225, False: 294k]
  ------------------
  124|  25.4k|    case Opcode::I32AtomicRmw16SubU:
  ------------------
  |  Branch (124:5): [True: 201, False: 294k]
  ------------------
  125|  25.6k|    case Opcode::I64AtomicRmw8SubU:
  ------------------
  |  Branch (125:5): [True: 196, False: 294k]
  ------------------
  126|  25.8k|    case Opcode::I64AtomicRmw16SubU:
  ------------------
  |  Branch (126:5): [True: 197, False: 294k]
  ------------------
  127|  26.2k|    case Opcode::I64AtomicRmw32SubU:
  ------------------
  |  Branch (127:5): [True: 423, False: 293k]
  ------------------
  128|  26.6k|    case Opcode::I32AtomicRmwAnd:
  ------------------
  |  Branch (128:5): [True: 324, False: 294k]
  ------------------
  129|  27.0k|    case Opcode::I64AtomicRmwAnd:
  ------------------
  |  Branch (129:5): [True: 407, False: 294k]
  ------------------
  130|  27.2k|    case Opcode::I32AtomicRmw8AndU:
  ------------------
  |  Branch (130:5): [True: 194, False: 294k]
  ------------------
  131|  27.4k|    case Opcode::I32AtomicRmw16AndU:
  ------------------
  |  Branch (131:5): [True: 194, False: 294k]
  ------------------
  132|  29.9k|    case Opcode::I64AtomicRmw8AndU:
  ------------------
  |  Branch (132:5): [True: 2.57k, False: 291k]
  ------------------
  133|  30.1k|    case Opcode::I64AtomicRmw16AndU:
  ------------------
  |  Branch (133:5): [True: 212, False: 294k]
  ------------------
  134|  30.3k|    case Opcode::I64AtomicRmw32AndU:
  ------------------
  |  Branch (134:5): [True: 194, False: 294k]
  ------------------
  135|  30.6k|    case Opcode::I32AtomicRmwOr:
  ------------------
  |  Branch (135:5): [True: 313, False: 294k]
  ------------------
  136|  30.9k|    case Opcode::I64AtomicRmwOr:
  ------------------
  |  Branch (136:5): [True: 239, False: 294k]
  ------------------
  137|  31.1k|    case Opcode::I32AtomicRmw8OrU:
  ------------------
  |  Branch (137:5): [True: 219, False: 294k]
  ------------------
  138|  31.3k|    case Opcode::I32AtomicRmw16OrU:
  ------------------
  |  Branch (138:5): [True: 215, False: 294k]
  ------------------
  139|  32.3k|    case Opcode::I64AtomicRmw8OrU:
  ------------------
  |  Branch (139:5): [True: 974, False: 293k]
  ------------------
  140|  32.5k|    case Opcode::I64AtomicRmw16OrU:
  ------------------
  |  Branch (140:5): [True: 198, False: 294k]
  ------------------
  141|  32.7k|    case Opcode::I64AtomicRmw32OrU:
  ------------------
  |  Branch (141:5): [True: 197, False: 294k]
  ------------------
  142|  32.9k|    case Opcode::I32AtomicRmwXor:
  ------------------
  |  Branch (142:5): [True: 200, False: 294k]
  ------------------
  143|  33.1k|    case Opcode::I64AtomicRmwXor:
  ------------------
  |  Branch (143:5): [True: 194, False: 294k]
  ------------------
  144|  33.3k|    case Opcode::I32AtomicRmw8XorU:
  ------------------
  |  Branch (144:5): [True: 194, False: 294k]
  ------------------
  145|  35.3k|    case Opcode::I32AtomicRmw16XorU:
  ------------------
  |  Branch (145:5): [True: 1.99k, False: 292k]
  ------------------
  146|  35.6k|    case Opcode::I64AtomicRmw8XorU:
  ------------------
  |  Branch (146:5): [True: 299, False: 294k]
  ------------------
  147|  35.8k|    case Opcode::I64AtomicRmw16XorU:
  ------------------
  |  Branch (147:5): [True: 226, False: 294k]
  ------------------
  148|  36.1k|    case Opcode::I64AtomicRmw32XorU:
  ------------------
  |  Branch (148:5): [True: 266, False: 294k]
  ------------------
  149|  36.3k|    case Opcode::I32AtomicRmwXchg:
  ------------------
  |  Branch (149:5): [True: 223, False: 294k]
  ------------------
  150|  36.5k|    case Opcode::I64AtomicRmwXchg:
  ------------------
  |  Branch (150:5): [True: 199, False: 294k]
  ------------------
  151|  36.8k|    case Opcode::I32AtomicRmw8XchgU:
  ------------------
  |  Branch (151:5): [True: 333, False: 294k]
  ------------------
  152|  37.0k|    case Opcode::I32AtomicRmw16XchgU:
  ------------------
  |  Branch (152:5): [True: 199, False: 294k]
  ------------------
  153|  37.2k|    case Opcode::I64AtomicRmw8XchgU:
  ------------------
  |  Branch (153:5): [True: 194, False: 294k]
  ------------------
  154|  37.4k|    case Opcode::I64AtomicRmw16XchgU:
  ------------------
  |  Branch (154:5): [True: 219, False: 294k]
  ------------------
  155|  37.6k|    case Opcode::I64AtomicRmw32XchgU:
  ------------------
  |  Branch (155:5): [True: 213, False: 294k]
  ------------------
  156|  38.0k|    case Opcode::I32AtomicRmwCmpxchg:
  ------------------
  |  Branch (156:5): [True: 381, False: 294k]
  ------------------
  157|  38.3k|    case Opcode::I64AtomicRmwCmpxchg:
  ------------------
  |  Branch (157:5): [True: 270, False: 294k]
  ------------------
  158|  38.5k|    case Opcode::I32AtomicRmw8CmpxchgU:
  ------------------
  |  Branch (158:5): [True: 260, False: 294k]
  ------------------
  159|  38.8k|    case Opcode::I32AtomicRmw16CmpxchgU:
  ------------------
  |  Branch (159:5): [True: 211, False: 294k]
  ------------------
  160|  39.1k|    case Opcode::I64AtomicRmw8CmpxchgU:
  ------------------
  |  Branch (160:5): [True: 365, False: 294k]
  ------------------
  161|  47.7k|    case Opcode::I64AtomicRmw16CmpxchgU:
  ------------------
  |  Branch (161:5): [True: 8.62k, False: 285k]
  ------------------
  162|  48.1k|    case Opcode::I64AtomicRmw32CmpxchgU:
  ------------------
  |  Branch (162:5): [True: 322, False: 294k]
  ------------------
  163|  48.1k|      return features.threads_enabled();
  164|       |
  165|  62.6k|    case Opcode::V128Const:
  ------------------
  |  Branch (165:5): [True: 62.6k, False: 231k]
  ------------------
  166|  62.6k|    case Opcode::V128Load:
  ------------------
  |  Branch (166:5): [True: 0, False: 294k]
  ------------------
  167|  62.6k|    case Opcode::V128Store:
  ------------------
  |  Branch (167:5): [True: 0, False: 294k]
  ------------------
  168|  62.8k|    case Opcode::I8X16Splat:
  ------------------
  |  Branch (168:5): [True: 197, False: 294k]
  ------------------
  169|  63.0k|    case Opcode::I16X8Splat:
  ------------------
  |  Branch (169:5): [True: 194, False: 294k]
  ------------------
  170|  63.2k|    case Opcode::I32X4Splat:
  ------------------
  |  Branch (170:5): [True: 220, False: 294k]
  ------------------
  171|  63.4k|    case Opcode::I64X2Splat:
  ------------------
  |  Branch (171:5): [True: 194, False: 294k]
  ------------------
  172|  63.6k|    case Opcode::F32X4Splat:
  ------------------
  |  Branch (172:5): [True: 245, False: 294k]
  ------------------
  173|  63.8k|    case Opcode::F64X2Splat:
  ------------------
  |  Branch (173:5): [True: 196, False: 294k]
  ------------------
  174|  64.0k|    case Opcode::I8X16ExtractLaneS:
  ------------------
  |  Branch (174:5): [True: 196, False: 294k]
  ------------------
  175|  64.2k|    case Opcode::I8X16ExtractLaneU:
  ------------------
  |  Branch (175:5): [True: 234, False: 294k]
  ------------------
  176|  64.5k|    case Opcode::I16X8ExtractLaneS:
  ------------------
  |  Branch (176:5): [True: 301, False: 294k]
  ------------------
  177|  64.7k|    case Opcode::I16X8ExtractLaneU:
  ------------------
  |  Branch (177:5): [True: 200, False: 294k]
  ------------------
  178|  65.5k|    case Opcode::I32X4ExtractLane:
  ------------------
  |  Branch (178:5): [True: 745, False: 293k]
  ------------------
  179|  65.7k|    case Opcode::I64X2ExtractLane:
  ------------------
  |  Branch (179:5): [True: 208, False: 294k]
  ------------------
  180|  66.0k|    case Opcode::F32X4ExtractLane:
  ------------------
  |  Branch (180:5): [True: 305, False: 294k]
  ------------------
  181|  66.2k|    case Opcode::F64X2ExtractLane:
  ------------------
  |  Branch (181:5): [True: 203, False: 294k]
  ------------------
  182|  66.4k|    case Opcode::I8X16ReplaceLane:
  ------------------
  |  Branch (182:5): [True: 194, False: 294k]
  ------------------
  183|  66.6k|    case Opcode::I16X8ReplaceLane:
  ------------------
  |  Branch (183:5): [True: 197, False: 294k]
  ------------------
  184|  66.9k|    case Opcode::I32X4ReplaceLane:
  ------------------
  |  Branch (184:5): [True: 305, False: 294k]
  ------------------
  185|  67.3k|    case Opcode::I64X2ReplaceLane:
  ------------------
  |  Branch (185:5): [True: 360, False: 294k]
  ------------------
  186|  67.5k|    case Opcode::F32X4ReplaceLane:
  ------------------
  |  Branch (186:5): [True: 198, False: 294k]
  ------------------
  187|  67.7k|    case Opcode::F64X2ReplaceLane:
  ------------------
  |  Branch (187:5): [True: 236, False: 294k]
  ------------------
  188|  67.9k|    case Opcode::I8X16Add:
  ------------------
  |  Branch (188:5): [True: 201, False: 294k]
  ------------------
  189|  68.1k|    case Opcode::I16X8Add:
  ------------------
  |  Branch (189:5): [True: 194, False: 294k]
  ------------------
  190|  68.3k|    case Opcode::I32X4Add:
  ------------------
  |  Branch (190:5): [True: 194, False: 294k]
  ------------------
  191|  69.1k|    case Opcode::I64X2Add:
  ------------------
  |  Branch (191:5): [True: 805, False: 293k]
  ------------------
  192|  69.3k|    case Opcode::I8X16Sub:
  ------------------
  |  Branch (192:5): [True: 198, False: 294k]
  ------------------
  193|  69.5k|    case Opcode::I16X8Sub:
  ------------------
  |  Branch (193:5): [True: 196, False: 294k]
  ------------------
  194|  69.7k|    case Opcode::I32X4Sub:
  ------------------
  |  Branch (194:5): [True: 196, False: 294k]
  ------------------
  195|  69.9k|    case Opcode::I64X2Sub:
  ------------------
  |  Branch (195:5): [True: 238, False: 294k]
  ------------------
  196|  70.1k|    case Opcode::I16X8Mul:
  ------------------
  |  Branch (196:5): [True: 231, False: 294k]
  ------------------
  197|  70.3k|    case Opcode::I32X4Mul:
  ------------------
  |  Branch (197:5): [True: 196, False: 294k]
  ------------------
  198|  70.5k|    case Opcode::I8X16Neg:
  ------------------
  |  Branch (198:5): [True: 194, False: 294k]
  ------------------
  199|  70.7k|    case Opcode::I16X8Neg:
  ------------------
  |  Branch (199:5): [True: 212, False: 294k]
  ------------------
  200|  71.0k|    case Opcode::I32X4Neg:
  ------------------
  |  Branch (200:5): [True: 211, False: 294k]
  ------------------
  201|  71.1k|    case Opcode::I64X2Neg:
  ------------------
  |  Branch (201:5): [True: 196, False: 294k]
  ------------------
  202|  71.3k|    case Opcode::I8X16AddSatS:
  ------------------
  |  Branch (202:5): [True: 194, False: 294k]
  ------------------
  203|  71.5k|    case Opcode::I8X16AddSatU:
  ------------------
  |  Branch (203:5): [True: 194, False: 294k]
  ------------------
  204|  71.7k|    case Opcode::I16X8AddSatS:
  ------------------
  |  Branch (204:5): [True: 194, False: 294k]
  ------------------
  205|  72.2k|    case Opcode::I16X8AddSatU:
  ------------------
  |  Branch (205:5): [True: 488, False: 293k]
  ------------------
  206|  72.4k|    case Opcode::I8X16SubSatS:
  ------------------
  |  Branch (206:5): [True: 194, False: 294k]
  ------------------
  207|  73.0k|    case Opcode::I8X16SubSatU:
  ------------------
  |  Branch (207:5): [True: 554, False: 293k]
  ------------------
  208|  73.2k|    case Opcode::I16X8SubSatS:
  ------------------
  |  Branch (208:5): [True: 199, False: 294k]
  ------------------
  209|  73.4k|    case Opcode::I16X8SubSatU:
  ------------------
  |  Branch (209:5): [True: 194, False: 294k]
  ------------------
  210|  73.7k|    case Opcode::I8X16Shl:
  ------------------
  |  Branch (210:5): [True: 356, False: 294k]
  ------------------
  211|  73.9k|    case Opcode::I16X8Shl:
  ------------------
  |  Branch (211:5): [True: 197, False: 294k]
  ------------------
  212|  74.1k|    case Opcode::I32X4Shl:
  ------------------
  |  Branch (212:5): [True: 200, False: 294k]
  ------------------
  213|  81.2k|    case Opcode::I64X2Shl:
  ------------------
  |  Branch (213:5): [True: 7.09k, False: 287k]
  ------------------
  214|  81.4k|    case Opcode::I8X16ShrS:
  ------------------
  |  Branch (214:5): [True: 194, False: 294k]
  ------------------
  215|  81.6k|    case Opcode::I8X16ShrU:
  ------------------
  |  Branch (215:5): [True: 194, False: 294k]
  ------------------
  216|  83.1k|    case Opcode::I16X8ShrS:
  ------------------
  |  Branch (216:5): [True: 1.52k, False: 292k]
  ------------------
  217|  83.9k|    case Opcode::I16X8ShrU:
  ------------------
  |  Branch (217:5): [True: 792, False: 293k]
  ------------------
  218|  84.1k|    case Opcode::I32X4ShrS:
  ------------------
  |  Branch (218:5): [True: 194, False: 294k]
  ------------------
  219|  84.3k|    case Opcode::I32X4ShrU:
  ------------------
  |  Branch (219:5): [True: 194, False: 294k]
  ------------------
  220|  84.5k|    case Opcode::I64X2ShrS:
  ------------------
  |  Branch (220:5): [True: 194, False: 294k]
  ------------------
  221|  84.7k|    case Opcode::I64X2ShrU:
  ------------------
  |  Branch (221:5): [True: 194, False: 294k]
  ------------------
  222|  84.9k|    case Opcode::V128And:
  ------------------
  |  Branch (222:5): [True: 195, False: 294k]
  ------------------
  223|  85.3k|    case Opcode::V128Or:
  ------------------
  |  Branch (223:5): [True: 385, False: 294k]
  ------------------
  224|  85.5k|    case Opcode::V128Xor:
  ------------------
  |  Branch (224:5): [True: 213, False: 294k]
  ------------------
  225|  85.7k|    case Opcode::V128Not:
  ------------------
  |  Branch (225:5): [True: 229, False: 294k]
  ------------------
  226|  86.2k|    case Opcode::V128BitSelect:
  ------------------
  |  Branch (226:5): [True: 460, False: 293k]
  ------------------
  227|  86.4k|    case Opcode::V128AnyTrue:
  ------------------
  |  Branch (227:5): [True: 204, False: 294k]
  ------------------
  228|  86.6k|    case Opcode::I8X16Bitmask:
  ------------------
  |  Branch (228:5): [True: 195, False: 294k]
  ------------------
  229|  86.8k|    case Opcode::I16X8Bitmask:
  ------------------
  |  Branch (229:5): [True: 194, False: 294k]
  ------------------
  230|  87.0k|    case Opcode::I32X4Bitmask:
  ------------------
  |  Branch (230:5): [True: 218, False: 294k]
  ------------------
  231|  87.6k|    case Opcode::I64X2Bitmask:
  ------------------
  |  Branch (231:5): [True: 580, False: 293k]
  ------------------
  232|  92.9k|    case Opcode::I8X16AllTrue:
  ------------------
  |  Branch (232:5): [True: 5.37k, False: 289k]
  ------------------
  233|  93.1k|    case Opcode::I16X8AllTrue:
  ------------------
  |  Branch (233:5): [True: 199, False: 294k]
  ------------------
  234|  93.3k|    case Opcode::I32X4AllTrue:
  ------------------
  |  Branch (234:5): [True: 194, False: 294k]
  ------------------
  235|  93.5k|    case Opcode::I64X2AllTrue:
  ------------------
  |  Branch (235:5): [True: 198, False: 294k]
  ------------------
  236|  93.5k|    case Opcode::I8X16Eq:
  ------------------
  |  Branch (236:5): [True: 0, False: 294k]
  ------------------
  237|  93.5k|    case Opcode::I16X8Eq:
  ------------------
  |  Branch (237:5): [True: 0, False: 294k]
  ------------------
  238|  93.5k|    case Opcode::I32X4Eq:
  ------------------
  |  Branch (238:5): [True: 0, False: 294k]
  ------------------
  239|  93.5k|    case Opcode::F32X4Eq:
  ------------------
  |  Branch (239:5): [True: 0, False: 294k]
  ------------------
  240|  93.5k|    case Opcode::F64X2Eq:
  ------------------
  |  Branch (240:5): [True: 0, False: 294k]
  ------------------
  241|  93.5k|    case Opcode::I8X16Ne:
  ------------------
  |  Branch (241:5): [True: 0, False: 294k]
  ------------------
  242|  93.5k|    case Opcode::I16X8Ne:
  ------------------
  |  Branch (242:5): [True: 0, False: 294k]
  ------------------
  243|  93.5k|    case Opcode::I32X4Ne:
  ------------------
  |  Branch (243:5): [True: 0, False: 294k]
  ------------------
  244|  93.5k|    case Opcode::F32X4Ne:
  ------------------
  |  Branch (244:5): [True: 0, False: 294k]
  ------------------
  245|  93.5k|    case Opcode::F64X2Ne:
  ------------------
  |  Branch (245:5): [True: 0, False: 294k]
  ------------------
  246|  93.5k|    case Opcode::I8X16LtS:
  ------------------
  |  Branch (246:5): [True: 0, False: 294k]
  ------------------
  247|  93.5k|    case Opcode::I8X16LtU:
  ------------------
  |  Branch (247:5): [True: 0, False: 294k]
  ------------------
  248|  93.5k|    case Opcode::I16X8LtS:
  ------------------
  |  Branch (248:5): [True: 0, False: 294k]
  ------------------
  249|  93.5k|    case Opcode::I16X8LtU:
  ------------------
  |  Branch (249:5): [True: 0, False: 294k]
  ------------------
  250|  93.5k|    case Opcode::I32X4LtS:
  ------------------
  |  Branch (250:5): [True: 0, False: 294k]
  ------------------
  251|  93.5k|    case Opcode::I32X4LtU:
  ------------------
  |  Branch (251:5): [True: 0, False: 294k]
  ------------------
  252|  93.5k|    case Opcode::F32X4Lt:
  ------------------
  |  Branch (252:5): [True: 0, False: 294k]
  ------------------
  253|  93.5k|    case Opcode::F64X2Lt:
  ------------------
  |  Branch (253:5): [True: 0, False: 294k]
  ------------------
  254|  93.5k|    case Opcode::I8X16LeS:
  ------------------
  |  Branch (254:5): [True: 0, False: 294k]
  ------------------
  255|  93.5k|    case Opcode::I8X16LeU:
  ------------------
  |  Branch (255:5): [True: 0, False: 294k]
  ------------------
  256|  93.5k|    case Opcode::I16X8LeS:
  ------------------
  |  Branch (256:5): [True: 0, False: 294k]
  ------------------
  257|  93.5k|    case Opcode::I16X8LeU:
  ------------------
  |  Branch (257:5): [True: 0, False: 294k]
  ------------------
  258|  93.5k|    case Opcode::I32X4LeS:
  ------------------
  |  Branch (258:5): [True: 0, False: 294k]
  ------------------
  259|  93.5k|    case Opcode::I32X4LeU:
  ------------------
  |  Branch (259:5): [True: 0, False: 294k]
  ------------------
  260|  93.5k|    case Opcode::F32X4Le:
  ------------------
  |  Branch (260:5): [True: 0, False: 294k]
  ------------------
  261|  93.5k|    case Opcode::F64X2Le:
  ------------------
  |  Branch (261:5): [True: 0, False: 294k]
  ------------------
  262|  93.5k|    case Opcode::I8X16GtS:
  ------------------
  |  Branch (262:5): [True: 0, False: 294k]
  ------------------
  263|  93.5k|    case Opcode::I8X16GtU:
  ------------------
  |  Branch (263:5): [True: 0, False: 294k]
  ------------------
  264|  93.5k|    case Opcode::I16X8GtS:
  ------------------
  |  Branch (264:5): [True: 0, False: 294k]
  ------------------
  265|  93.5k|    case Opcode::I16X8GtU:
  ------------------
  |  Branch (265:5): [True: 0, False: 294k]
  ------------------
  266|  93.5k|    case Opcode::I32X4GtS:
  ------------------
  |  Branch (266:5): [True: 0, False: 294k]
  ------------------
  267|  93.5k|    case Opcode::I32X4GtU:
  ------------------
  |  Branch (267:5): [True: 0, False: 294k]
  ------------------
  268|  93.5k|    case Opcode::F32X4Gt:
  ------------------
  |  Branch (268:5): [True: 0, False: 294k]
  ------------------
  269|  93.5k|    case Opcode::F64X2Gt:
  ------------------
  |  Branch (269:5): [True: 0, False: 294k]
  ------------------
  270|  93.5k|    case Opcode::I8X16GeS:
  ------------------
  |  Branch (270:5): [True: 0, False: 294k]
  ------------------
  271|  93.5k|    case Opcode::I8X16GeU:
  ------------------
  |  Branch (271:5): [True: 0, False: 294k]
  ------------------
  272|  93.5k|    case Opcode::I16X8GeS:
  ------------------
  |  Branch (272:5): [True: 0, False: 294k]
  ------------------
  273|  93.5k|    case Opcode::I16X8GeU:
  ------------------
  |  Branch (273:5): [True: 0, False: 294k]
  ------------------
  274|  93.5k|    case Opcode::I32X4GeS:
  ------------------
  |  Branch (274:5): [True: 0, False: 294k]
  ------------------
  275|  93.5k|    case Opcode::I32X4GeU:
  ------------------
  |  Branch (275:5): [True: 0, False: 294k]
  ------------------
  276|  93.5k|    case Opcode::F32X4Ge:
  ------------------
  |  Branch (276:5): [True: 0, False: 294k]
  ------------------
  277|  93.5k|    case Opcode::F64X2Ge:
  ------------------
  |  Branch (277:5): [True: 0, False: 294k]
  ------------------
  278|  93.7k|    case Opcode::F32X4Neg:
  ------------------
  |  Branch (278:5): [True: 203, False: 294k]
  ------------------
  279|  94.1k|    case Opcode::F64X2Neg:
  ------------------
  |  Branch (279:5): [True: 400, False: 294k]
  ------------------
  280|  94.3k|    case Opcode::F32X4Abs:
  ------------------
  |  Branch (280:5): [True: 203, False: 294k]
  ------------------
  281|  94.5k|    case Opcode::F64X2Abs:
  ------------------
  |  Branch (281:5): [True: 194, False: 294k]
  ------------------
  282|  94.7k|    case Opcode::F32X4Min:
  ------------------
  |  Branch (282:5): [True: 199, False: 294k]
  ------------------
  283|  94.9k|    case Opcode::F32X4PMin:
  ------------------
  |  Branch (283:5): [True: 194, False: 294k]
  ------------------
  284|  95.1k|    case Opcode::F64X2Min:
  ------------------
  |  Branch (284:5): [True: 194, False: 294k]
  ------------------
  285|  95.3k|    case Opcode::F64X2PMin:
  ------------------
  |  Branch (285:5): [True: 195, False: 294k]
  ------------------
  286|  95.5k|    case Opcode::F32X4Max:
  ------------------
  |  Branch (286:5): [True: 195, False: 294k]
  ------------------
  287|  95.7k|    case Opcode::F32X4PMax:
  ------------------
  |  Branch (287:5): [True: 195, False: 294k]
  ------------------
  288|  95.9k|    case Opcode::F64X2Max:
  ------------------
  |  Branch (288:5): [True: 204, False: 294k]
  ------------------
  289|  96.1k|    case Opcode::F64X2PMax:
  ------------------
  |  Branch (289:5): [True: 194, False: 294k]
  ------------------
  290|  96.3k|    case Opcode::F32X4Add:
  ------------------
  |  Branch (290:5): [True: 194, False: 294k]
  ------------------
  291|  96.5k|    case Opcode::F64X2Add:
  ------------------
  |  Branch (291:5): [True: 194, False: 294k]
  ------------------
  292|  96.7k|    case Opcode::F32X4Sub:
  ------------------
  |  Branch (292:5): [True: 230, False: 294k]
  ------------------
  293|  97.3k|    case Opcode::F64X2Sub:
  ------------------
  |  Branch (293:5): [True: 567, False: 293k]
  ------------------
  294|  97.5k|    case Opcode::F32X4Div:
  ------------------
  |  Branch (294:5): [True: 194, False: 294k]
  ------------------
  295|  97.7k|    case Opcode::F64X2Div:
  ------------------
  |  Branch (295:5): [True: 194, False: 294k]
  ------------------
  296|  97.9k|    case Opcode::F32X4Mul:
  ------------------
  |  Branch (296:5): [True: 219, False: 294k]
  ------------------
  297|  98.1k|    case Opcode::F64X2Mul:
  ------------------
  |  Branch (297:5): [True: 243, False: 294k]
  ------------------
  298|  98.3k|    case Opcode::F32X4Sqrt:
  ------------------
  |  Branch (298:5): [True: 194, False: 294k]
  ------------------
  299|  98.5k|    case Opcode::F64X2Sqrt:
  ------------------
  |  Branch (299:5): [True: 194, False: 294k]
  ------------------
  300|  98.7k|    case Opcode::F32X4ConvertI32X4S:
  ------------------
  |  Branch (300:5): [True: 194, False: 294k]
  ------------------
  301|  98.9k|    case Opcode::F32X4ConvertI32X4U:
  ------------------
  |  Branch (301:5): [True: 194, False: 294k]
  ------------------
  302|  99.3k|    case Opcode::I32X4TruncSatF32X4S:
  ------------------
  |  Branch (302:5): [True: 370, False: 294k]
  ------------------
  303|   101k|    case Opcode::I32X4TruncSatF32X4U:
  ------------------
  |  Branch (303:5): [True: 1.73k, False: 292k]
  ------------------
  304|   101k|    case Opcode::I8X16Swizzle:
  ------------------
  |  Branch (304:5): [True: 194, False: 294k]
  ------------------
  305|   104k|    case Opcode::I8X16Shuffle:
  ------------------
  |  Branch (305:5): [True: 3.12k, False: 291k]
  ------------------
  306|   104k|    case Opcode::V128Load8Splat:
  ------------------
  |  Branch (306:5): [True: 0, False: 294k]
  ------------------
  307|   104k|    case Opcode::V128Load16Splat:
  ------------------
  |  Branch (307:5): [True: 0, False: 294k]
  ------------------
  308|   104k|    case Opcode::V128Load32Splat:
  ------------------
  |  Branch (308:5): [True: 0, False: 294k]
  ------------------
  309|   104k|    case Opcode::V128Load64Splat:
  ------------------
  |  Branch (309:5): [True: 0, False: 294k]
  ------------------
  310|   104k|    case Opcode::V128Load8Lane:
  ------------------
  |  Branch (310:5): [True: 378, False: 294k]
  ------------------
  311|   104k|    case Opcode::V128Load16Lane:
  ------------------
  |  Branch (311:5): [True: 194, False: 294k]
  ------------------
  312|   105k|    case Opcode::V128Load32Lane:
  ------------------
  |  Branch (312:5): [True: 295, False: 294k]
  ------------------
  313|   105k|    case Opcode::V128Load64Lane:
  ------------------
  |  Branch (313:5): [True: 414, False: 294k]
  ------------------
  314|   106k|    case Opcode::V128Store8Lane:
  ------------------
  |  Branch (314:5): [True: 741, False: 293k]
  ------------------
  315|   107k|    case Opcode::V128Store16Lane:
  ------------------
  |  Branch (315:5): [True: 887, False: 293k]
  ------------------
  316|   107k|    case Opcode::V128Store32Lane:
  ------------------
  |  Branch (316:5): [True: 331, False: 294k]
  ------------------
  317|   107k|    case Opcode::V128Store64Lane:
  ------------------
  |  Branch (317:5): [True: 195, False: 294k]
  ------------------
  318|   108k|    case Opcode::I8X16Abs:
  ------------------
  |  Branch (318:5): [True: 270, False: 294k]
  ------------------
  319|   108k|    case Opcode::I16X8Abs:
  ------------------
  |  Branch (319:5): [True: 197, False: 294k]
  ------------------
  320|   108k|    case Opcode::I32X4Abs:
  ------------------
  |  Branch (320:5): [True: 268, False: 294k]
  ------------------
  321|   108k|      return features.simd_enabled();
  322|       |
  323|    194|    case Opcode::I8X16RelaxedSwizzle:
  ------------------
  |  Branch (323:5): [True: 194, False: 294k]
  ------------------
  324|    428|    case Opcode::I32X4RelaxedTruncF32X4S:
  ------------------
  |  Branch (324:5): [True: 234, False: 294k]
  ------------------
  325|    794|    case Opcode::I32X4RelaxedTruncF32X4U:
  ------------------
  |  Branch (325:5): [True: 366, False: 294k]
  ------------------
  326|    988|    case Opcode::I32X4RelaxedTruncF64X2SZero:
  ------------------
  |  Branch (326:5): [True: 194, False: 294k]
  ------------------
  327|  1.18k|    case Opcode::I32X4RelaxedTruncF64X2UZero:
  ------------------
  |  Branch (327:5): [True: 194, False: 294k]
  ------------------
  328|  1.37k|    case Opcode::F32X4RelaxedMadd:
  ------------------
  |  Branch (328:5): [True: 196, False: 294k]
  ------------------
  329|  1.62k|    case Opcode::F32X4RelaxedNmadd:
  ------------------
  |  Branch (329:5): [True: 243, False: 294k]
  ------------------
  330|  1.90k|    case Opcode::F64X2RelaxedMadd:
  ------------------
  |  Branch (330:5): [True: 279, False: 294k]
  ------------------
  331|  2.09k|    case Opcode::F64X2RelaxedNmadd:
  ------------------
  |  Branch (331:5): [True: 199, False: 294k]
  ------------------
  332|  3.88k|    case Opcode::I8X16RelaxedLaneSelect:
  ------------------
  |  Branch (332:5): [True: 1.78k, False: 292k]
  ------------------
  333|  4.08k|    case Opcode::I16X8RelaxedLaneSelect:
  ------------------
  |  Branch (333:5): [True: 195, False: 294k]
  ------------------
  334|  4.29k|    case Opcode::I32X4RelaxedLaneSelect:
  ------------------
  |  Branch (334:5): [True: 212, False: 294k]
  ------------------
  335|  4.67k|    case Opcode::I64X2RelaxedLaneSelect:
  ------------------
  |  Branch (335:5): [True: 378, False: 294k]
  ------------------
  336|  4.92k|    case Opcode::F32X4RelaxedMin:
  ------------------
  |  Branch (336:5): [True: 259, False: 294k]
  ------------------
  337|  5.12k|    case Opcode::F32X4RelaxedMax:
  ------------------
  |  Branch (337:5): [True: 194, False: 294k]
  ------------------
  338|  5.32k|    case Opcode::F64X2RelaxedMin:
  ------------------
  |  Branch (338:5): [True: 203, False: 294k]
  ------------------
  339|  5.57k|    case Opcode::F64X2RelaxedMax:
  ------------------
  |  Branch (339:5): [True: 251, False: 294k]
  ------------------
  340|  5.77k|    case Opcode::I16X8RelaxedQ15mulrS:
  ------------------
  |  Branch (340:5): [True: 194, False: 294k]
  ------------------
  341|  5.96k|    case Opcode::I16X8DotI8X16I7X16S:
  ------------------
  |  Branch (341:5): [True: 194, False: 294k]
  ------------------
  342|  6.16k|    case Opcode::I32X4DotI8X16I7X16AddS:
  ------------------
  |  Branch (342:5): [True: 198, False: 294k]
  ------------------
  343|  6.16k|      return features.relaxed_simd_enabled();
  344|       |
  345|  2.06k|    case Opcode::MemoryInit:
  ------------------
  |  Branch (345:5): [True: 2.06k, False: 292k]
  ------------------
  346|  3.51k|    case Opcode::DataDrop:
  ------------------
  |  Branch (346:5): [True: 1.45k, False: 292k]
  ------------------
  347|  4.38k|    case Opcode::MemoryCopy:
  ------------------
  |  Branch (347:5): [True: 870, False: 293k]
  ------------------
  348|  5.10k|    case Opcode::MemoryFill:
  ------------------
  |  Branch (348:5): [True: 721, False: 293k]
  ------------------
  349|  10.2k|    case Opcode::TableInit:
  ------------------
  |  Branch (349:5): [True: 5.18k, False: 289k]
  ------------------
  350|  12.0k|    case Opcode::ElemDrop:
  ------------------
  |  Branch (350:5): [True: 1.79k, False: 292k]
  ------------------
  351|  14.6k|    case Opcode::TableCopy:
  ------------------
  |  Branch (351:5): [True: 2.55k, False: 291k]
  ------------------
  352|  14.6k|      return features.bulk_memory_enabled();
  353|       |
  354|  1.07k|    case Opcode::TableGet:
  ------------------
  |  Branch (354:5): [True: 1.07k, False: 293k]
  ------------------
  355|  2.32k|    case Opcode::TableSet:
  ------------------
  |  Branch (355:5): [True: 1.25k, False: 293k]
  ------------------
  356|  4.24k|    case Opcode::TableGrow:
  ------------------
  |  Branch (356:5): [True: 1.91k, False: 292k]
  ------------------
  357|  6.20k|    case Opcode::TableSize:
  ------------------
  |  Branch (357:5): [True: 1.96k, False: 292k]
  ------------------
  358|  7.41k|    case Opcode::RefNull:
  ------------------
  |  Branch (358:5): [True: 1.21k, False: 293k]
  ------------------
  359|  7.92k|    case Opcode::RefIsNull:
  ------------------
  |  Branch (359:5): [True: 509, False: 293k]
  ------------------
  360|  7.92k|      return features.reference_types_enabled();
  361|       |
  362|    431|    case Opcode::CallRef:
  ------------------
  |  Branch (362:5): [True: 431, False: 293k]
  ------------------
  363|    431|      return features.function_references_enabled();
  364|       |
  365|       |    // Interpreter opcodes are never "enabled".
  366|      0|    case Opcode::InterpAlloca:
  ------------------
  |  Branch (366:5): [True: 0, False: 294k]
  ------------------
  367|      0|    case Opcode::InterpBrUnless:
  ------------------
  |  Branch (367:5): [True: 0, False: 294k]
  ------------------
  368|      0|    case Opcode::InterpCallImport:
  ------------------
  |  Branch (368:5): [True: 0, False: 294k]
  ------------------
  369|      0|    case Opcode::InterpData:
  ------------------
  |  Branch (369:5): [True: 0, False: 294k]
  ------------------
  370|      0|    case Opcode::InterpDropKeep:
  ------------------
  |  Branch (370:5): [True: 0, False: 294k]
  ------------------
  371|      0|      return false;
  372|       |
  373|  3.70k|    default:
  ------------------
  |  Branch (373:5): [True: 3.70k, False: 290k]
  ------------------
  374|  3.70k|      return true;
  375|   294k|  }
  376|   294k|}

wast-lexer.cc:_ZN4wabt12_GLOBAL__N_112Perfect_Hash9InWordSetEPKcm:
  158|  8.39M|{
  159|  8.39M|  enum
  160|  8.39M|    {
  161|  8.39M|      TOTAL_KEYWORDS = 601,
  162|  8.39M|      MIN_WORD_LENGTH = 2,
  163|  8.39M|      MAX_WORD_LENGTH = 35,
  164|  8.39M|      MIN_HASH_VALUE = 37,
  165|  8.39M|      MAX_HASH_VALUE = 2229
  166|  8.39M|    };
  167|       |
  168|  8.39M|  static struct TokenInfo wordlist[] =
  169|  8.39M|    {
  170|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  171|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  172|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  173|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  174|  8.39M|      {""},
  175|  8.39M|#line 35 "src/lexer-keywords.txt"
  176|  8.39M|      {"br", TokenType::Br, Opcode::Br},
  177|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  178|  8.39M|#line 152 "src/lexer-keywords.txt"
  179|  8.39M|      {"f64", Type::F64},
  180|  8.39M|      {""}, {""},
  181|  8.39M|#line 45 "src/lexer-keywords.txt"
  182|  8.39M|      {"data", TokenType::Data},
  183|  8.39M|      {""}, {""}, {""},
  184|  8.39M|#line 464 "src/lexer-keywords.txt"
  185|  8.39M|      {"i64", Type::I64},
  186|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  187|  8.39M|      {""}, {""}, {""},
  188|  8.39M|#line 122 "src/lexer-keywords.txt"
  189|  8.39M|      {"f32x4", TokenType::F32X4},
  190|  8.39M|      {""}, {""}, {""}, {""},
  191|  8.39M|#line 586 "src/lexer-keywords.txt"
  192|  8.39M|      {"table", TokenType::Table},
  193|  8.39M|#line 48 "src/lexer-keywords.txt"
  194|  8.39M|      {"do", TokenType::Do},
  195|  8.39M|#line 364 "src/lexer-keywords.txt"
  196|  8.39M|      {"i32x4", TokenType::I32X4},
  197|  8.39M|      {""}, {""}, {""},
  198|  8.39M|#line 135 "src/lexer-keywords.txt"
  199|  8.39M|      {"f64.ge", TokenType::Compare, Opcode::F64Ge},
  200|  8.39M|#line 74 "src/lexer-keywords.txt"
  201|  8.39M|      {"f32.ge", TokenType::Compare, Opcode::F32Ge},
  202|  8.39M|#line 137 "src/lexer-keywords.txt"
  203|  8.39M|      {"f64.le", TokenType::Compare, Opcode::F64Le},
  204|  8.39M|#line 76 "src/lexer-keywords.txt"
  205|  8.39M|      {"f32.le", TokenType::Compare, Opcode::F32Le},
  206|  8.39M|      {""}, {""}, {""}, {""}, {""},
  207|  8.39M|#line 30 "src/lexer-keywords.txt"
  208|  8.39M|      {"before", TokenType::Before},
  209|  8.39M|      {""}, {""}, {""}, {""}, {""},
  210|  8.39M|#line 187 "src/lexer-keywords.txt"
  211|  8.39M|      {"func", Type::FuncRef, TokenType::Func},
  212|  8.39M|#line 136 "src/lexer-keywords.txt"
  213|  8.39M|      {"f64.gt", TokenType::Compare, Opcode::F64Gt},
  214|  8.39M|#line 75 "src/lexer-keywords.txt"
  215|  8.39M|      {"f32.gt", TokenType::Compare, Opcode::F32Gt},
  216|  8.39M|#line 139 "src/lexer-keywords.txt"
  217|  8.39M|      {"f64.lt", TokenType::Compare, Opcode::F64Lt},
  218|  8.39M|#line 78 "src/lexer-keywords.txt"
  219|  8.39M|      {"f32.lt", TokenType::Compare, Opcode::F32Lt},
  220|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
  221|  8.39M|#line 43 "src/lexer-keywords.txt"
  222|  8.39M|      {"code", TokenType::Code},
  223|  8.39M|      {""}, {""}, {""},
  224|  8.39M|#line 570 "src/lexer-keywords.txt"
  225|  8.39M|      {"result", TokenType::Result},
  226|  8.39M|      {""},
  227|  8.39M|#line 100 "src/lexer-keywords.txt"
  228|  8.39M|      {"f32x4.ge", TokenType::Compare, Opcode::F32X4Ge},
  229|  8.39M|      {""},
  230|  8.39M|#line 102 "src/lexer-keywords.txt"
  231|  8.39M|      {"f32x4.le", TokenType::Compare, Opcode::F32X4Le},
  232|  8.39M|      {""},
  233|  8.39M|#line 578 "src/lexer-keywords.txt"
  234|  8.39M|      {"struct", Type::Struct, TokenType::Struct},
  235|  8.39M|      {""}, {""}, {""}, {""}, {""},
  236|  8.39M|#line 555 "src/lexer-keywords.txt"
  237|  8.39M|      {"mut", TokenType::Mut},
  238|  8.39M|#line 441 "src/lexer-keywords.txt"
  239|  8.39M|      {"i64.or", TokenType::Binary, Opcode::I64Or},
  240|  8.39M|#line 298 "src/lexer-keywords.txt"
  241|  8.39M|      {"i32.or", TokenType::Binary, Opcode::I32Or},
  242|  8.39M|      {""}, {""},
  243|  8.39M|#line 581 "src/lexer-keywords.txt"
  244|  8.39M|      {"table.get", TokenType::TableGet, Opcode::TableGet},
  245|  8.39M|#line 101 "src/lexer-keywords.txt"
  246|  8.39M|      {"f32x4.gt", TokenType::Compare, Opcode::F32X4Gt},
  247|  8.39M|#line 584 "src/lexer-keywords.txt"
  248|  8.39M|      {"table.set", TokenType::TableSet, Opcode::TableSet},
  249|  8.39M|#line 103 "src/lexer-keywords.txt"
  250|  8.39M|      {"f32x4.lt", TokenType::Compare, Opcode::F32X4Lt},
  251|  8.39M|#line 330 "src/lexer-keywords.txt"
  252|  8.39M|      {"i32x4.ge_u", TokenType::Compare, Opcode::I32X4GeU},
  253|  8.39M|      {""},
  254|  8.39M|#line 334 "src/lexer-keywords.txt"
  255|  8.39M|      {"i32x4.le_u", TokenType::Compare, Opcode::I32X4LeU},
  256|  8.39M|      {""},
  257|  8.39M|#line 329 "src/lexer-keywords.txt"
  258|  8.39M|      {"i32x4.ge_s", TokenType::Compare, Opcode::I32X4GeS},
  259|  8.39M|#line 93 "src/lexer-keywords.txt"
  260|  8.39M|      {"f32x4.ceil", TokenType::Unary, Opcode::F32X4Ceil},
  261|  8.39M|#line 333 "src/lexer-keywords.txt"
  262|  8.39M|      {"i32x4.le_s", TokenType::Compare, Opcode::I32X4LeS},
  263|  8.39M|      {""},
  264|  8.39M|#line 332 "src/lexer-keywords.txt"
  265|  8.39M|      {"i32x4.gt_u", TokenType::Compare, Opcode::I32X4GtU},
  266|  8.39M|      {""},
  267|  8.39M|#line 342 "src/lexer-keywords.txt"
  268|  8.39M|      {"i32x4.lt_u", TokenType::Compare, Opcode::I32X4LtU},
  269|  8.39M|      {""},
  270|  8.39M|#line 331 "src/lexer-keywords.txt"
  271|  8.39M|      {"i32x4.gt_s", TokenType::Compare, Opcode::I32X4GtS},
  272|  8.39M|      {""},
  273|  8.39M|#line 341 "src/lexer-keywords.txt"
  274|  8.39M|      {"i32x4.lt_s", TokenType::Compare, Opcode::I32X4LtS},
  275|  8.39M|#line 145 "src/lexer-keywords.txt"
  276|  8.39M|      {"f64.ne", TokenType::Compare, Opcode::F64Ne},
  277|  8.39M|#line 84 "src/lexer-keywords.txt"
  278|  8.39M|      {"f32.ne", TokenType::Compare, Opcode::F32Ne},
  279|  8.39M|      {""}, {""}, {""},
  280|  8.39M|#line 554 "src/lexer-keywords.txt"
  281|  8.39M|      {"module", TokenType::Module},
  282|  8.39M|      {""},
  283|  8.39M|#line 440 "src/lexer-keywords.txt"
  284|  8.39M|      {"i64.ne", TokenType::Compare, Opcode::I64Ne},
  285|  8.39M|#line 297 "src/lexer-keywords.txt"
  286|  8.39M|      {"i32.ne", TokenType::Compare, Opcode::I32Ne},
  287|  8.39M|#line 46 "src/lexer-keywords.txt"
  288|  8.39M|      {"declare", TokenType::Declare},
  289|  8.39M|      {""},
  290|  8.39M|#line 144 "src/lexer-keywords.txt"
  291|  8.39M|      {"f64.neg", TokenType::Unary, Opcode::F64Neg},
  292|  8.39M|#line 83 "src/lexer-keywords.txt"
  293|  8.39M|      {"f32.neg", TokenType::Unary, Opcode::F32Neg},
  294|  8.39M|      {""},
  295|  8.39M|#line 149 "src/lexer-keywords.txt"
  296|  8.39M|      {"f64.store", TokenType::Store, Opcode::F64Store},
  297|  8.39M|#line 87 "src/lexer-keywords.txt"
  298|  8.39M|      {"f32.store", TokenType::Store, Opcode::F32Store},
  299|  8.39M|      {""},
  300|  8.39M|#line 447 "src/lexer-keywords.txt"
  301|  8.39M|      {"i64.rotr", TokenType::Binary, Opcode::I64Rotr},
  302|  8.39M|#line 304 "src/lexer-keywords.txt"
  303|  8.39M|      {"i32.rotr", TokenType::Binary, Opcode::I32Rotr},
  304|  8.39M|#line 446 "src/lexer-keywords.txt"
  305|  8.39M|      {"i64.rotl", TokenType::Binary, Opcode::I64Rotl},
  306|  8.39M|#line 303 "src/lexer-keywords.txt"
  307|  8.39M|      {"i32.rotl", TokenType::Binary, Opcode::I32Rotl},
  308|  8.39M|#line 454 "src/lexer-keywords.txt"
  309|  8.39M|      {"i64.store", TokenType::Store, Opcode::I64Store},
  310|  8.39M|#line 310 "src/lexer-keywords.txt"
  311|  8.39M|      {"i32.store", TokenType::Store, Opcode::I32Store},
  312|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
  313|  8.39M|#line 568 "src/lexer-keywords.txt"
  314|  8.39M|      {"ref.null", TokenType::RefNull, Opcode::RefNull},
  315|  8.39M|#line 108 "src/lexer-keywords.txt"
  316|  8.39M|      {"f32x4.neg", TokenType::Unary, Opcode::F32X4Neg},
  317|  8.39M|      {""},
  318|  8.39M|#line 109 "src/lexer-keywords.txt"
  319|  8.39M|      {"f32x4.ne", TokenType::Compare, Opcode::F32X4Ne},
  320|  8.39M|      {""}, {""}, {""}, {""},
  321|  8.39M|#line 349 "src/lexer-keywords.txt"
  322|  8.39M|      {"i32x4.neg", TokenType::Unary, Opcode::I32X4Neg},
  323|  8.39M|      {""},
  324|  8.39M|#line 350 "src/lexer-keywords.txt"
  325|  8.39M|      {"i32x4.ne", TokenType::Compare, Opcode::I32X4Ne},
  326|  8.39M|      {""}, {""},
  327|  8.39M|#line 151 "src/lexer-keywords.txt"
  328|  8.39M|      {"f64.trunc", TokenType::Unary, Opcode::F64Trunc},
  329|  8.39M|#line 89 "src/lexer-keywords.txt"
  330|  8.39M|      {"f32.trunc", TokenType::Unary, Opcode::F32Trunc},
  331|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  332|  8.39M|      {""}, {""}, {""}, {""},
  333|  8.39M|#line 143 "src/lexer-keywords.txt"
  334|  8.39M|      {"f64.nearest", TokenType::Unary, Opcode::F64Nearest},
  335|  8.39M|#line 82 "src/lexer-keywords.txt"
  336|  8.39M|      {"f32.nearest", TokenType::Unary, Opcode::F32Nearest},
  337|  8.39M|      {""}, {""}, {""},
  338|  8.39M|#line 120 "src/lexer-keywords.txt"
  339|  8.39M|      {"f32x4.trunc", TokenType::Unary, Opcode::F32X4Trunc},
  340|  8.39M|#line 574 "src/lexer-keywords.txt"
  341|  8.39M|      {"return", TokenType::Return, Opcode::Return},
  342|  8.39M|      {""}, {""}, {""}, {""}, {""},
  343|  8.39M|#line 453 "src/lexer-keywords.txt"
  344|  8.39M|      {"i64.store8", TokenType::Store, Opcode::I64Store8},
  345|  8.39M|#line 309 "src/lexer-keywords.txt"
  346|  8.39M|      {"i32.store8", TokenType::Store, Opcode::I32Store8},
  347|  8.39M|#line 142 "src/lexer-keywords.txt"
  348|  8.39M|      {"f64.mul", TokenType::Binary, Opcode::F64Mul},
  349|  8.39M|#line 81 "src/lexer-keywords.txt"
  350|  8.39M|      {"f32.mul", TokenType::Binary, Opcode::F32Mul},
  351|  8.39M|#line 92 "src/lexer-keywords.txt"
  352|  8.39M|      {"f32x4.add", TokenType::Binary, Opcode::F32X4Add},
  353|  8.39M|#line 107 "src/lexer-keywords.txt"
  354|  8.39M|      {"f32x4.nearest", TokenType::Unary, Opcode::F32X4Nearest},
  355|  8.39M|      {""}, {""}, {""},
  356|  8.39M|#line 439 "src/lexer-keywords.txt"
  357|  8.39M|      {"i64.mul", TokenType::Binary, Opcode::I64Mul},
  358|  8.39M|#line 296 "src/lexer-keywords.txt"
  359|  8.39M|      {"i32.mul", TokenType::Binary, Opcode::I32Mul},
  360|  8.39M|#line 323 "src/lexer-keywords.txt"
  361|  8.39M|      {"i32x4.add", TokenType::Binary, Opcode::I32X4Add},
  362|  8.39M|      {""},
  363|  8.39M|#line 38 "src/lexer-keywords.txt"
  364|  8.39M|      {"call", TokenType::Call, Opcode::Call},
  365|  8.39M|      {""},
  366|  8.39M|#line 126 "src/lexer-keywords.txt"
  367|  8.39M|      {"f64.const", TokenType::Const, Opcode::F64Const},
  368|  8.39M|#line 64 "src/lexer-keywords.txt"
  369|  8.39M|      {"f32.const", TokenType::Const, Opcode::F32Const},
  370|  8.39M|      {""}, {""}, {""},
  371|  8.39M|#line 106 "src/lexer-keywords.txt"
  372|  8.39M|      {"f32x4.mul", TokenType::Binary, Opcode::F32X4Mul},
  373|  8.39M|      {""},
  374|  8.39M|#line 413 "src/lexer-keywords.txt"
  375|  8.39M|      {"i64.const", TokenType::Const, Opcode::I64Const},
  376|  8.39M|#line 275 "src/lexer-keywords.txt"
  377|  8.39M|      {"i32.const", TokenType::Const, Opcode::I32Const},
  378|  8.39M|      {""},
  379|  8.39M|#line 575 "src/lexer-keywords.txt"
  380|  8.39M|      {"select", TokenType::Select, Opcode::Select},
  381|  8.39M|      {""},
  382|  8.39M|#line 348 "src/lexer-keywords.txt"
  383|  8.39M|      {"i32x4.mul", TokenType::Binary, Opcode::I32X4Mul},
  384|  8.39M|      {""},
  385|  8.39M|#line 543 "src/lexer-keywords.txt"
  386|  8.39M|      {"local", TokenType::Local},
  387|  8.39M|      {""}, {""}, {""},
  388|  8.39M|#line 496 "src/lexer-keywords.txt"
  389|  8.39M|      {"i64.xor", TokenType::Binary, Opcode::I64Xor},
  390|  8.39M|#line 373 "src/lexer-keywords.txt"
  391|  8.39M|      {"i32.xor", TokenType::Binary, Opcode::I32Xor},
  392|  8.39M|#line 47 "src/lexer-keywords.txt"
  393|  8.39M|      {"delegate", TokenType::Delegate},
  394|  8.39M|      {""}, {""}, {""},
  395|  8.39M|#line 124 "src/lexer-keywords.txt"
  396|  8.39M|      {"f64.add", TokenType::Binary, Opcode::F64Add},
  397|  8.39M|#line 62 "src/lexer-keywords.txt"
  398|  8.39M|      {"f32.add", TokenType::Binary, Opcode::F32Add},
  399|  8.39M|#line 138 "src/lexer-keywords.txt"
  400|  8.39M|      {"f64.load", TokenType::Load, Opcode::F64Load},
  401|  8.39M|#line 77 "src/lexer-keywords.txt"
  402|  8.39M|      {"f32.load", TokenType::Load, Opcode::F32Load},
  403|  8.39M|      {""}, {""}, {""},
  404|  8.39M|#line 374 "src/lexer-keywords.txt"
  405|  8.39M|      {"i64.add", TokenType::Binary, Opcode::I64Add},
  406|  8.39M|#line 245 "src/lexer-keywords.txt"
  407|  8.39M|      {"i32.add", TokenType::Binary, Opcode::I32Add},
  408|  8.39M|#line 436 "src/lexer-keywords.txt"
  409|  8.39M|      {"i64.load", TokenType::Load, Opcode::I64Load},
  410|  8.39M|#line 293 "src/lexer-keywords.txt"
  411|  8.39M|      {"i32.load", TokenType::Load, Opcode::I32Load},
  412|  8.39M|      {""}, {""}, {""}, {""},
  413|  8.39M|#line 116 "src/lexer-keywords.txt"
  414|  8.39M|      {"f32x4.replace_lane", TokenType::SimdLaneOp, Opcode::F32X4ReplaceLane},
  415|  8.39M|      {""}, {""}, {""},
  416|  8.39M|#line 375 "src/lexer-keywords.txt"
  417|  8.39M|      {"i64.and", TokenType::Binary, Opcode::I64And},
  418|  8.39M|#line 246 "src/lexer-keywords.txt"
  419|  8.39M|      {"i32.and", TokenType::Binary, Opcode::I32And},
  420|  8.39M|      {""},
  421|  8.39M|#line 352 "src/lexer-keywords.txt"
  422|  8.39M|      {"i32x4.replace_lane", TokenType::SimdLaneOp, Opcode::I32X4ReplaceLane},
  423|  8.39M|      {""}, {""}, {""},
  424|  8.39M|#line 425 "src/lexer-keywords.txt"
  425|  8.39M|      {"i64.ge_u", TokenType::Compare, Opcode::I64GeU},
  426|  8.39M|#line 284 "src/lexer-keywords.txt"
  427|  8.39M|      {"i32.ge_u", TokenType::Compare, Opcode::I32GeU},
  428|  8.39M|#line 429 "src/lexer-keywords.txt"
  429|  8.39M|      {"i64.le_u", TokenType::Compare, Opcode::I64LeU},
  430|  8.39M|#line 288 "src/lexer-keywords.txt"
  431|  8.39M|      {"i32.le_u", TokenType::Compare, Opcode::I32LeU},
  432|  8.39M|#line 424 "src/lexer-keywords.txt"
  433|  8.39M|      {"i64.ge_s", TokenType::Compare, Opcode::I64GeS},
  434|  8.39M|#line 283 "src/lexer-keywords.txt"
  435|  8.39M|      {"i32.ge_s", TokenType::Compare, Opcode::I32GeS},
  436|  8.39M|#line 428 "src/lexer-keywords.txt"
  437|  8.39M|      {"i64.le_s", TokenType::Compare, Opcode::I64LeS},
  438|  8.39M|#line 287 "src/lexer-keywords.txt"
  439|  8.39M|      {"i32.le_s", TokenType::Compare, Opcode::I32LeS},
  440|  8.39M|#line 427 "src/lexer-keywords.txt"
  441|  8.39M|      {"i64.gt_u", TokenType::Compare, Opcode::I64GtU},
  442|  8.39M|#line 286 "src/lexer-keywords.txt"
  443|  8.39M|      {"i32.gt_u", TokenType::Compare, Opcode::I32GtU},
  444|  8.39M|#line 438 "src/lexer-keywords.txt"
  445|  8.39M|      {"i64.lt_u", TokenType::Compare, Opcode::I64LtU},
  446|  8.39M|#line 295 "src/lexer-keywords.txt"
  447|  8.39M|      {"i32.lt_u", TokenType::Compare, Opcode::I32LtU},
  448|  8.39M|#line 426 "src/lexer-keywords.txt"
  449|  8.39M|      {"i64.gt_s", TokenType::Compare, Opcode::I64GtS},
  450|  8.39M|#line 285 "src/lexer-keywords.txt"
  451|  8.39M|      {"i32.gt_s", TokenType::Compare, Opcode::I32GtS},
  452|  8.39M|#line 437 "src/lexer-keywords.txt"
  453|  8.39M|      {"i64.lt_s", TokenType::Compare, Opcode::I64LtS},
  454|  8.39M|#line 294 "src/lexer-keywords.txt"
  455|  8.39M|      {"i32.lt_s", TokenType::Compare, Opcode::I32LtS},
  456|  8.39M|      {""}, {""}, {""},
  457|  8.39M|#line 540 "src/lexer-keywords.txt"
  458|  8.39M|      {"local.get", TokenType::LocalGet, Opcode::LocalGet},
  459|  8.39M|      {""},
  460|  8.39M|#line 541 "src/lexer-keywords.txt"
  461|  8.39M|      {"local.set", TokenType::LocalSet, Opcode::LocalSet},
  462|  8.39M|#line 542 "src/lexer-keywords.txt"
  463|  8.39M|      {"local.tee", TokenType::LocalTee, Opcode::LocalTee},
  464|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  465|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  466|  8.39M|      {""},
  467|  8.39M|#line 351 "src/lexer-keywords.txt"
  468|  8.39M|      {"i32x4.relaxed_laneselect", TokenType::Ternary, Opcode::I32X4RelaxedLaneSelect},
  469|  8.39M|#line 324 "src/lexer-keywords.txt"
  470|  8.39M|      {"i32x4.all_true", TokenType::Unary, Opcode::I32X4AllTrue},
  471|  8.39M|      {""},
  472|  8.39M|#line 125 "src/lexer-keywords.txt"
  473|  8.39M|      {"f64.ceil", TokenType::Unary, Opcode::F64Ceil},
  474|  8.39M|#line 63 "src/lexer-keywords.txt"
  475|  8.39M|      {"f32.ceil", TokenType::Unary, Opcode::F32Ceil},
  476|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  477|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  478|  8.39M|#line 585 "src/lexer-keywords.txt"
  479|  8.39M|      {"table.size", TokenType::TableSize, Opcode::TableSize},
  480|  8.39M|      {""}, {""}, {""},
  481|  8.39M|#line 104 "src/lexer-keywords.txt"
  482|  8.39M|      {"f32x4.max", TokenType::Binary, Opcode::F32X4Max},
  483|  8.39M|#line 535 "src/lexer-keywords.txt"
  484|  8.39M|      {"if", TokenType::If, Opcode::If},
  485|  8.39M|#line 411 "src/lexer-keywords.txt"
  486|  8.39M|      {"i64.atomic.store", TokenType::AtomicStore, Opcode::I64AtomicStore},
  487|  8.39M|#line 273 "src/lexer-keywords.txt"
  488|  8.39M|      {"i32.atomic.store", TokenType::AtomicStore, Opcode::I32AtomicStore},
  489|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
  490|  8.39M|#line 563 "src/lexer-keywords.txt"
  491|  8.39M|      {"ref", TokenType::Ref},
  492|  8.39M|      {""}, {""},
  493|  8.39M|#line 404 "src/lexer-keywords.txt"
  494|  8.39M|      {"i64.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I64AtomicRmwOr},
  495|  8.39M|#line 267 "src/lexer-keywords.txt"
  496|  8.39M|      {"i32.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I32AtomicRmwOr},
  497|  8.39M|      {""}, {""}, {""}, {""}, {""},
  498|  8.39M|#line 573 "src/lexer-keywords.txt"
  499|  8.39M|      {"return_call", TokenType::ReturnCall, Opcode::ReturnCall},
  500|  8.39M|      {""}, {""},
  501|  8.39M|#line 53 "src/lexer-keywords.txt"
  502|  8.39M|      {"else", TokenType::Else, Opcode::Else},
  503|  8.39M|      {""}, {""}, {""}, {""}, {""},
  504|  8.39M|#line 55 "src/lexer-keywords.txt"
  505|  8.39M|      {"tag", TokenType::Tag},
  506|  8.39M|      {""},
  507|  8.39M|#line 98 "src/lexer-keywords.txt"
  508|  8.39M|      {"f32x4.extract_lane", TokenType::SimdLaneOp, Opcode::F32X4ExtractLane},
  509|  8.39M|#line 565 "src/lexer-keywords.txt"
  510|  8.39M|      {"ref.extern", TokenType::RefExtern},
  511|  8.39M|#line 338 "src/lexer-keywords.txt"
  512|  8.39M|      {"i32x4.relaxed_trunc_f64x2_u_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2UZero},
  513|  8.39M|#line 90 "src/lexer-keywords.txt"
  514|  8.39M|      {"f32", Type::F32},
  515|  8.39M|#line 337 "src/lexer-keywords.txt"
  516|  8.39M|      {"i32x4.relaxed_trunc_f64x2_s_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2SZero},
  517|  8.39M|      {""}, {""},
  518|  8.39M|#line 328 "src/lexer-keywords.txt"
  519|  8.39M|      {"i32x4.extract_lane", TokenType::SimdLaneOp, Opcode::I32X4ExtractLane},
  520|  8.39M|      {""},
  521|  8.39M|#line 189 "src/lexer-keywords.txt"
  522|  8.39M|      {"get", TokenType::Get},
  523|  8.39M|#line 320 "src/lexer-keywords.txt"
  524|  8.39M|      {"i32", Type::I32},
  525|  8.39M|#line 50 "src/lexer-keywords.txt"
  526|  8.39M|      {"either", TokenType::Either},
  527|  8.39M|      {""}, {""},
  528|  8.39M|#line 391 "src/lexer-keywords.txt"
  529|  8.39M|      {"i64.atomic.rmw32.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32SubU},
  530|  8.39M|#line 435 "src/lexer-keywords.txt"
  531|  8.39M|      {"i64.load8_u", TokenType::Load, Opcode::I64Load8U},
  532|  8.39M|#line 292 "src/lexer-keywords.txt"
  533|  8.39M|      {"i32.load8_u", TokenType::Load, Opcode::I32Load8U},
  534|  8.39M|#line 434 "src/lexer-keywords.txt"
  535|  8.39M|      {"i64.load8_s", TokenType::Load, Opcode::I64Load8S},
  536|  8.39M|#line 291 "src/lexer-keywords.txt"
  537|  8.39M|      {"i32.load8_s", TokenType::Load, Opcode::I32Load8S},
  538|  8.39M|      {""},
  539|  8.39M|#line 410 "src/lexer-keywords.txt"
  540|  8.39M|      {"i64.atomic.store8", TokenType::AtomicStore, Opcode::I64AtomicStore8},
  541|  8.39M|#line 272 "src/lexer-keywords.txt"
  542|  8.39M|      {"i32.atomic.store8", TokenType::AtomicStore, Opcode::I32AtomicStore8},
  543|  8.39M|#line 431 "src/lexer-keywords.txt"
  544|  8.39M|      {"i64.load16_u", TokenType::Load, Opcode::I64Load16U},
  545|  8.39M|#line 290 "src/lexer-keywords.txt"
  546|  8.39M|      {"i32.load16_u", TokenType::Load, Opcode::I32Load16U},
  547|  8.39M|#line 457 "src/lexer-keywords.txt"
  548|  8.39M|      {"i64.trunc_f32_u", TokenType::Convert, Opcode::I64TruncF32U},
  549|  8.39M|#line 313 "src/lexer-keywords.txt"
  550|  8.39M|      {"i32.trunc_f32_u", TokenType::Convert, Opcode::I32TruncF32U},
  551|  8.39M|#line 430 "src/lexer-keywords.txt"
  552|  8.39M|      {"i64.load16_s", TokenType::Load, Opcode::I64Load16S},
  553|  8.39M|#line 289 "src/lexer-keywords.txt"
  554|  8.39M|      {"i32.load16_s", TokenType::Load, Opcode::I32Load16S},
  555|  8.39M|#line 456 "src/lexer-keywords.txt"
  556|  8.39M|      {"i64.trunc_f32_s", TokenType::Convert, Opcode::I64TruncF32S},
  557|  8.39M|#line 312 "src/lexer-keywords.txt"
  558|  8.39M|      {"i32.trunc_f32_s", TokenType::Convert, Opcode::I32TruncF32S},
  559|  8.39M|#line 445 "src/lexer-keywords.txt"
  560|  8.39M|      {"i64.rem_u", TokenType::Binary, Opcode::I64RemU},
  561|  8.39M|#line 302 "src/lexer-keywords.txt"
  562|  8.39M|      {"i32.rem_u", TokenType::Binary, Opcode::I32RemU},
  563|  8.39M|#line 444 "src/lexer-keywords.txt"
  564|  8.39M|      {"i64.rem_s", TokenType::Binary, Opcode::I64RemS},
  565|  8.39M|#line 301 "src/lexer-keywords.txt"
  566|  8.39M|      {"i32.rem_s", TokenType::Binary, Opcode::I32RemS},
  567|  8.39M|      {""},
  568|  8.39M|#line 54 "src/lexer-keywords.txt"
  569|  8.39M|      {"end", TokenType::End, Opcode::End},
  570|  8.39M|      {""},
  571|  8.39M|#line 407 "src/lexer-keywords.txt"
  572|  8.39M|      {"i64.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I64AtomicRmwXor},
  573|  8.39M|#line 270 "src/lexer-keywords.txt"
  574|  8.39M|      {"i32.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I32AtomicRmwXor},
  575|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
  576|  8.39M|#line 587 "src/lexer-keywords.txt"
  577|  8.39M|      {"then", TokenType::Then},
  578|  8.39M|#line 583 "src/lexer-keywords.txt"
  579|  8.39M|      {"table.init", TokenType::TableInit, Opcode::TableInit},
  580|  8.39M|      {""}, {""},
  581|  8.39M|#line 344 "src/lexer-keywords.txt"
  582|  8.39M|      {"i32x4.max_u", TokenType::Binary, Opcode::I32X4MaxU},
  583|  8.39M|      {""},
  584|  8.39M|#line 343 "src/lexer-keywords.txt"
  585|  8.39M|      {"i32x4.max_s", TokenType::Binary, Opcode::I32X4MaxS},
  586|  8.39M|      {""},
  587|  8.39M|#line 390 "src/lexer-keywords.txt"
  588|  8.39M|      {"i64.atomic.rmw32.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32OrU},
  589|  8.39M|#line 448 "src/lexer-keywords.txt"
  590|  8.39M|      {"i64.shl", TokenType::Binary, Opcode::I64Shl},
  591|  8.39M|#line 305 "src/lexer-keywords.txt"
  592|  8.39M|      {"i32.shl", TokenType::Binary, Opcode::I32Shl},
  593|  8.39M|      {""}, {""},
  594|  8.39M|#line 114 "src/lexer-keywords.txt"
  595|  8.39M|      {"f32x4.relaxed_min", TokenType::Binary, Opcode::F32X4RelaxedMin},
  596|  8.39M|      {""},
  597|  8.39M|#line 115 "src/lexer-keywords.txt"
  598|  8.39M|      {"f32x4.relaxed_nmadd", TokenType::Ternary, Opcode::F32X4RelaxedNmadd},
  599|  8.39M|#line 140 "src/lexer-keywords.txt"
  600|  8.39M|      {"f64.max", TokenType::Binary, Opcode::F64Max},
  601|  8.39M|#line 79 "src/lexer-keywords.txt"
  602|  8.39M|      {"f32.max", TokenType::Binary, Opcode::F32Max},
  603|  8.39M|      {""}, {""},
  604|  8.39M|#line 160 "src/lexer-keywords.txt"
  605|  8.39M|      {"f64x2.ge", TokenType::Compare, Opcode::F64X2Ge},
  606|  8.39M|      {""},
  607|  8.39M|#line 162 "src/lexer-keywords.txt"
  608|  8.39M|      {"f64x2.le", TokenType::Compare, Opcode::F64X2Le},
  609|  8.39M|      {""}, {""},
  610|  8.39M|#line 387 "src/lexer-keywords.txt"
  611|  8.39M|      {"i64.atomic.rmw32.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AddU},
  612|  8.39M|      {""},
  613|  8.39M|#line 353 "src/lexer-keywords.txt"
  614|  8.39M|      {"i32x4.shl", TokenType::Binary, Opcode::I32X4Shl},
  615|  8.39M|      {""}, {""},
  616|  8.39M|#line 569 "src/lexer-keywords.txt"
  617|  8.39M|      {"register", TokenType::Register},
  618|  8.39M|#line 379 "src/lexer-keywords.txt"
  619|  8.39M|      {"i64.atomic.load", TokenType::AtomicLoad, Opcode::I64AtomicLoad},
  620|  8.39M|#line 249 "src/lexer-keywords.txt"
  621|  8.39M|      {"i32.atomic.load", TokenType::AtomicLoad, Opcode::I32AtomicLoad},
  622|  8.39M|      {""}, {""}, {""},
  623|  8.39M|#line 161 "src/lexer-keywords.txt"
  624|  8.39M|      {"f64x2.gt", TokenType::Compare, Opcode::F64X2Gt},
  625|  8.39M|#line 388 "src/lexer-keywords.txt"
  626|  8.39M|      {"i64.atomic.rmw32.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AndU},
  627|  8.39M|#line 163 "src/lexer-keywords.txt"
  628|  8.39M|      {"f64x2.lt", TokenType::Compare, Opcode::F64X2Lt},
  629|  8.39M|      {""},
  630|  8.39M|#line 58 "src/lexer-keywords.txt"
  631|  8.39M|      {"exn", Type::ExnRef, TokenType::Exn},
  632|  8.39M|      {""}, {""},
  633|  8.39M|#line 475 "src/lexer-keywords.txt"
  634|  8.39M|      {"i64x2.ge_s", TokenType::Binary, Opcode::I64X2GeS},
  635|  8.39M|#line 155 "src/lexer-keywords.txt"
  636|  8.39M|      {"f64x2.ceil", TokenType::Unary, Opcode::F64X2Ceil},
  637|  8.39M|#line 474 "src/lexer-keywords.txt"
  638|  8.39M|      {"i64x2.le_s", TokenType::Binary, Opcode::I64X2LeS},
  639|  8.39M|      {""}, {""}, {""}, {""}, {""},
  640|  8.39M|#line 473 "src/lexer-keywords.txt"
  641|  8.39M|      {"i64x2.gt_s", TokenType::Binary, Opcode::I64X2GtS},
  642|  8.39M|      {""},
  643|  8.39M|#line 472 "src/lexer-keywords.txt"
  644|  8.39M|      {"i64x2.lt_s", TokenType::Binary, Opcode::I64X2LtS},
  645|  8.39M|#line 99 "src/lexer-keywords.txt"
  646|  8.39M|      {"f32x4.floor", TokenType::Unary, Opcode::F32X4Floor},
  647|  8.39M|      {""}, {""},
  648|  8.39M|#line 185 "src/lexer-keywords.txt"
  649|  8.39M|      {"field", TokenType::Field},
  650|  8.39M|#line 112 "src/lexer-keywords.txt"
  651|  8.39M|      {"f32x4.relaxed_madd", TokenType::Ternary, Opcode::F32X4RelaxedMadd},
  652|  8.39M|      {""}, {""}, {""}, {""}, {""},
  653|  8.39M|#line 419 "src/lexer-keywords.txt"
  654|  8.39M|      {"i64.extend16_s", TokenType::Unary, Opcode::I64Extend16S},
  655|  8.39M|#line 281 "src/lexer-keywords.txt"
  656|  8.39M|      {"i32.extend16_s", TokenType::Unary, Opcode::I32Extend16S},
  657|  8.39M|      {""},
  658|  8.39M|#line 539 "src/lexer-keywords.txt"
  659|  8.39M|      {"item", TokenType::Item},
  660|  8.39M|      {""}, {""},
  661|  8.39M|#line 421 "src/lexer-keywords.txt"
  662|  8.39M|      {"i64.extend8_s", TokenType::Unary, Opcode::I64Extend8S},
  663|  8.39M|#line 282 "src/lexer-keywords.txt"
  664|  8.39M|      {"i32.extend8_s", TokenType::Unary, Opcode::I32Extend8S},
  665|  8.39M|      {""}, {""},
  666|  8.39M|#line 566 "src/lexer-keywords.txt"
  667|  8.39M|      {"ref.func", TokenType::RefFunc, Opcode::RefFunc},
  668|  8.39M|#line 134 "src/lexer-keywords.txt"
  669|  8.39M|      {"f64.floor", TokenType::Unary, Opcode::F64Floor},
  670|  8.39M|#line 73 "src/lexer-keywords.txt"
  671|  8.39M|      {"f32.floor", TokenType::Unary, Opcode::F32Floor},
  672|  8.39M|      {""}, {""},
  673|  8.39M|#line 412 "src/lexer-keywords.txt"
  674|  8.39M|      {"i64.clz", TokenType::Unary, Opcode::I64Clz},
  675|  8.39M|#line 274 "src/lexer-keywords.txt"
  676|  8.39M|      {"i32.clz", TokenType::Unary, Opcode::I32Clz},
  677|  8.39M|      {""}, {""}, {""}, {""},
  678|  8.39M|#line 168 "src/lexer-keywords.txt"
  679|  8.39M|      {"f64x2.neg", TokenType::Unary, Opcode::F64X2Neg},
  680|  8.39M|#line 105 "src/lexer-keywords.txt"
  681|  8.39M|      {"f32x4.min", TokenType::Binary, Opcode::F32X4Min},
  682|  8.39M|#line 169 "src/lexer-keywords.txt"
  683|  8.39M|      {"f64x2.ne", TokenType::Compare, Opcode::F64X2Ne},
  684|  8.39M|#line 414 "src/lexer-keywords.txt"
  685|  8.39M|      {"i64.ctz", TokenType::Unary, Opcode::I64Ctz},
  686|  8.39M|#line 276 "src/lexer-keywords.txt"
  687|  8.39M|      {"i32.ctz", TokenType::Unary, Opcode::I32Ctz},
  688|  8.39M|      {""}, {""},
  689|  8.39M|#line 477 "src/lexer-keywords.txt"
  690|  8.39M|      {"i64x2.neg", TokenType::Unary, Opcode::I64X2Neg},
  691|  8.39M|#line 452 "src/lexer-keywords.txt"
  692|  8.39M|      {"i64.store32", TokenType::Store, Opcode::I64Store32},
  693|  8.39M|#line 471 "src/lexer-keywords.txt"
  694|  8.39M|      {"i64x2.ne", TokenType::Binary, Opcode::I64X2Ne},
  695|  8.39M|      {""},
  696|  8.39M|#line 56 "src/lexer-keywords.txt"
  697|  8.39M|      {"extern", Type::ExternRef, TokenType::Extern},
  698|  8.39M|#line 394 "src/lexer-keywords.txt"
  699|  8.39M|      {"i64.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AddU},
  700|  8.39M|#line 257 "src/lexer-keywords.txt"
  701|  8.39M|      {"i32.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AddU},
  702|  8.39M|      {""}, {""},
  703|  8.39M|#line 392 "src/lexer-keywords.txt"
  704|  8.39M|      {"i64.atomic.rmw32.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XchgU},
  705|  8.39M|      {""},
  706|  8.39M|#line 113 "src/lexer-keywords.txt"
  707|  8.39M|      {"f32x4.relaxed_max", TokenType::Binary, Opcode::F32X4RelaxedMax},
  708|  8.39M|      {""}, {""}, {""}, {""}, {""},
  709|  8.39M|#line 395 "src/lexer-keywords.txt"
  710|  8.39M|      {"i64.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AndU},
  711|  8.39M|#line 258 "src/lexer-keywords.txt"
  712|  8.39M|      {"i32.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AndU},
  713|  8.39M|      {""}, {""},
  714|  8.39M|#line 188 "src/lexer-keywords.txt"
  715|  8.39M|      {"function", TokenType::Function},
  716|  8.39M|#line 401 "src/lexer-keywords.txt"
  717|  8.39M|      {"i64.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I64AtomicRmwAdd},
  718|  8.39M|#line 264 "src/lexer-keywords.txt"
  719|  8.39M|      {"i32.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I32AtomicRmwAdd},
  720|  8.39M|      {""},
  721|  8.39M|#line 180 "src/lexer-keywords.txt"
  722|  8.39M|      {"f64x2.trunc", TokenType::Unary, Opcode::F64X2Trunc},
  723|  8.39M|      {""}, {""},
  724|  8.39M|#line 393 "src/lexer-keywords.txt"
  725|  8.39M|      {"i64.atomic.rmw32.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XorU},
  726|  8.39M|      {""}, {""},
  727|  8.39M|#line 557 "src/lexer-keywords.txt"
  728|  8.39M|      {"nan:canonical", TokenType::NanCanonical},
  729|  8.39M|      {""}, {""},
  730|  8.39M|#line 402 "src/lexer-keywords.txt"
  731|  8.39M|      {"i64.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I64AtomicRmwAnd},
  732|  8.39M|#line 265 "src/lexer-keywords.txt"
  733|  8.39M|      {"i32.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I32AtomicRmwAnd},
  734|  8.39M|#line 154 "src/lexer-keywords.txt"
  735|  8.39M|      {"f64x2.add", TokenType::Binary, Opcode::F64X2Add},
  736|  8.39M|#line 167 "src/lexer-keywords.txt"
  737|  8.39M|      {"f64x2.nearest", TokenType::Unary, Opcode::F64X2Nearest},
  738|  8.39M|      {""}, {""}, {""},
  739|  8.39M|#line 141 "src/lexer-keywords.txt"
  740|  8.39M|      {"f64.min", TokenType::Binary, Opcode::F64Min},
  741|  8.39M|#line 80 "src/lexer-keywords.txt"
  742|  8.39M|      {"f32.min", TokenType::Binary, Opcode::F32Min},
  743|  8.39M|#line 465 "src/lexer-keywords.txt"
  744|  8.39M|      {"i64x2.add", TokenType::Binary, Opcode::I64X2Add},
  745|  8.39M|      {""}, {""},
  746|  8.39M|#line 400 "src/lexer-keywords.txt"
  747|  8.39M|      {"i64.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XorU},
  748|  8.39M|#line 263 "src/lexer-keywords.txt"
  749|  8.39M|      {"i32.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XorU},
  750|  8.39M|      {""},
  751|  8.39M|#line 459 "src/lexer-keywords.txt"
  752|  8.39M|      {"i64.trunc_f64_u", TokenType::Convert, Opcode::I64TruncF64U},
  753|  8.39M|#line 315 "src/lexer-keywords.txt"
  754|  8.39M|      {"i32.trunc_f64_u", TokenType::Convert, Opcode::I32TruncF64U},
  755|  8.39M|      {""},
  756|  8.39M|#line 166 "src/lexer-keywords.txt"
  757|  8.39M|      {"f64x2.mul", TokenType::Binary, Opcode::F64X2Mul},
  758|  8.39M|#line 458 "src/lexer-keywords.txt"
  759|  8.39M|      {"i64.trunc_f64_s", TokenType::Convert, Opcode::I64TruncF64S},
  760|  8.39M|#line 314 "src/lexer-keywords.txt"
  761|  8.39M|      {"i32.trunc_f64_s", TokenType::Convert, Opcode::I32TruncF64S},
  762|  8.39M|#line 567 "src/lexer-keywords.txt"
  763|  8.39M|      {"ref.is_null", TokenType::RefIsNull, Opcode::RefIsNull},
  764|  8.39M|#line 605 "src/lexer-keywords.txt"
  765|  8.39M|      {"v128", Type::V128},
  766|  8.39M|      {""}, {""},
  767|  8.39M|#line 469 "src/lexer-keywords.txt"
  768|  8.39M|      {"i64x2.mul", TokenType::Binary, Opcode::I64X2Mul},
  769|  8.39M|#line 433 "src/lexer-keywords.txt"
  770|  8.39M|      {"i64.load32_u", TokenType::Load, Opcode::I64Load32U},
  771|  8.39M|      {""}, {""}, {""},
  772|  8.39M|#line 432 "src/lexer-keywords.txt"
  773|  8.39M|      {"i64.load32_s", TokenType::Load, Opcode::I64Load32S},
  774|  8.39M|      {""}, {""}, {""}, {""},
  775|  8.39M|#line 556 "src/lexer-keywords.txt"
  776|  8.39M|      {"nan:arithmetic", TokenType::NanArithmetic},
  777|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
  778|  8.39M|#line 538 "src/lexer-keywords.txt"
  779|  8.39M|      {"invoke", TokenType::Invoke},
  780|  8.39M|      {""}, {""}, {""}, {""}, {""},
  781|  8.39M|#line 378 "src/lexer-keywords.txt"
  782|  8.39M|      {"i64.atomic.load8_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad8U},
  783|  8.39M|#line 248 "src/lexer-keywords.txt"
  784|  8.39M|      {"i32.atomic.load8_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad8U},
  785|  8.39M|      {""},
  786|  8.39M|#line 176 "src/lexer-keywords.txt"
  787|  8.39M|      {"f64x2.replace_lane", TokenType::SimdLaneOp, Opcode::F64X2ReplaceLane},
  788|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
  789|  8.39M|#line 485 "src/lexer-keywords.txt"
  790|  8.39M|      {"i64x2.replace_lane", TokenType::SimdLaneOp, Opcode::I64X2ReplaceLane},
  791|  8.39M|      {""},
  792|  8.39M|#line 564 "src/lexer-keywords.txt"
  793|  8.39M|      {"quote", TokenType::Quote},
  794|  8.39M|#line 32 "src/lexer-keywords.txt"
  795|  8.39M|      {"block", TokenType::Block, Opcode::Block},
  796|  8.39M|      {""}, {""},
  797|  8.39M|#line 450 "src/lexer-keywords.txt"
  798|  8.39M|      {"i64.shr_u", TokenType::Binary, Opcode::I64ShrU},
  799|  8.39M|#line 307 "src/lexer-keywords.txt"
  800|  8.39M|      {"i32.shr_u", TokenType::Binary, Opcode::I32ShrU},
  801|  8.39M|#line 449 "src/lexer-keywords.txt"
  802|  8.39M|      {"i64.shr_s", TokenType::Binary, Opcode::I64ShrS},
  803|  8.39M|#line 306 "src/lexer-keywords.txt"
  804|  8.39M|      {"i32.shr_s", TokenType::Binary, Opcode::I32ShrS},
  805|  8.39M|#line 397 "src/lexer-keywords.txt"
  806|  8.39M|      {"i64.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8OrU},
  807|  8.39M|#line 260 "src/lexer-keywords.txt"
  808|  8.39M|      {"i32.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8OrU},
  809|  8.39M|#line 240 "src/lexer-keywords.txt"
  810|  8.39M|      {"i16x8", TokenType::I16X8},
  811|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  812|  8.39M|      {""}, {""}, {""},
  813|  8.39M|#line 355 "src/lexer-keywords.txt"
  814|  8.39M|      {"i32x4.shr_u", TokenType::Binary, Opcode::I32X4ShrU},
  815|  8.39M|#line 346 "src/lexer-keywords.txt"
  816|  8.39M|      {"i32x4.min_u", TokenType::Binary, Opcode::I32X4MinU},
  817|  8.39M|#line 354 "src/lexer-keywords.txt"
  818|  8.39M|      {"i32x4.shr_s", TokenType::Binary, Opcode::I32X4ShrS},
  819|  8.39M|#line 345 "src/lexer-keywords.txt"
  820|  8.39M|      {"i32x4.min_s", TokenType::Binary, Opcode::I32X4MinS},
  821|  8.39M|#line 600 "src/lexer-keywords.txt"
  822|  8.39M|      {"v128.or", TokenType::Binary, Opcode::V128Or},
  823|  8.39M|      {""},
  824|  8.39M|#line 560 "src/lexer-keywords.txt"
  825|  8.39M|      {"output", TokenType::Output},
  826|  8.39M|      {""}, {""},
  827|  8.39M|#line 559 "src/lexer-keywords.txt"
  828|  8.39M|      {"offset", TokenType::Offset},
  829|  8.39M|      {""},
  830|  8.39M|#line 592 "src/lexer-keywords.txt"
  831|  8.39M|      {"type", TokenType::Type},
  832|  8.39M|#line 590 "src/lexer-keywords.txt"
  833|  8.39M|      {"try", TokenType::Try, Opcode::Try},
  834|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
  835|  8.39M|#line 580 "src/lexer-keywords.txt"
  836|  8.39M|      {"table.fill", TokenType::TableFill, Opcode::TableFill},
  837|  8.39M|      {""},
  838|  8.39M|#line 484 "src/lexer-keywords.txt"
  839|  8.39M|      {"i64x2.relaxed_laneselect", TokenType::Ternary, Opcode::I64X2RelaxedLaneSelect},
  840|  8.39M|#line 478 "src/lexer-keywords.txt"
  841|  8.39M|      {"i64x2.all_true", TokenType::Unary, Opcode::I64X2AllTrue},
  842|  8.39M|      {""}, {""}, {""}, {""}, {""},
  843|  8.39M|#line 205 "src/lexer-keywords.txt"
  844|  8.39M|      {"i16x8.ge_u", TokenType::Compare, Opcode::I16X8GeU},
  845|  8.39M|#line 420 "src/lexer-keywords.txt"
  846|  8.39M|      {"i64.extend32_s", TokenType::Unary, Opcode::I64Extend32S},
  847|  8.39M|#line 209 "src/lexer-keywords.txt"
  848|  8.39M|      {"i16x8.le_u", TokenType::Compare, Opcode::I16X8LeU},
  849|  8.39M|      {""},
  850|  8.39M|#line 204 "src/lexer-keywords.txt"
  851|  8.39M|      {"i16x8.ge_s", TokenType::Compare, Opcode::I16X8GeS},
  852|  8.39M|#line 40 "src/lexer-keywords.txt"
  853|  8.39M|      {"catch_all", TokenType::CatchAll, Opcode::CatchAll},
  854|  8.39M|#line 208 "src/lexer-keywords.txt"
  855|  8.39M|      {"i16x8.le_s", TokenType::Compare, Opcode::I16X8LeS},
  856|  8.39M|#line 336 "src/lexer-keywords.txt"
  857|  8.39M|      {"i32x4.relaxed_trunc_f32x4_u", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4U},
  858|  8.39M|#line 207 "src/lexer-keywords.txt"
  859|  8.39M|      {"i16x8.gt_u", TokenType::Compare, Opcode::I16X8GtU},
  860|  8.39M|      {""},
  861|  8.39M|#line 213 "src/lexer-keywords.txt"
  862|  8.39M|      {"i16x8.lt_u", TokenType::Compare, Opcode::I16X8LtU},
  863|  8.39M|#line 335 "src/lexer-keywords.txt"
  864|  8.39M|      {"i32x4.relaxed_trunc_f32x4_s", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4S},
  865|  8.39M|#line 206 "src/lexer-keywords.txt"
  866|  8.39M|      {"i16x8.gt_s", TokenType::Compare, Opcode::I16X8GtS},
  867|  8.39M|      {""},
  868|  8.39M|#line 212 "src/lexer-keywords.txt"
  869|  8.39M|      {"i16x8.lt_s", TokenType::Compare, Opcode::I16X8LtS},
  870|  8.39M|      {""}, {""},
  871|  8.39M|#line 70 "src/lexer-keywords.txt"
  872|  8.39M|      {"f32.demote_f64", TokenType::Convert, Opcode::F32DemoteF64},
  873|  8.39M|      {""},
  874|  8.39M|#line 164 "src/lexer-keywords.txt"
  875|  8.39M|      {"f64x2.max", TokenType::Binary, Opcode::F64X2Max},
  876|  8.39M|      {""},
  877|  8.39M|#line 117 "src/lexer-keywords.txt"
  878|  8.39M|      {"f32x4.splat", TokenType::Unary, Opcode::F32X4Splat},
  879|  8.39M|#line 604 "src/lexer-keywords.txt"
  880|  8.39M|      {"v128.store", TokenType::Store, Opcode::V128Store},
  881|  8.39M|#line 537 "src/lexer-keywords.txt"
  882|  8.39M|      {"input", TokenType::Input},
  883|  8.39M|      {""}, {""},
  884|  8.39M|#line 572 "src/lexer-keywords.txt"
  885|  8.39M|      {"return_call_indirect", TokenType::ReturnCallIndirect, Opcode::ReturnCallIndirect},
  886|  8.39M|      {""},
  887|  8.39M|#line 356 "src/lexer-keywords.txt"
  888|  8.39M|      {"i32x4.splat", TokenType::Unary, Opcode::I32X4Splat},
  889|  8.39M|#line 508 "src/lexer-keywords.txt"
  890|  8.39M|      {"i8x16.ge_u", TokenType::Compare, Opcode::I8X16GeU},
  891|  8.39M|#line 33 "src/lexer-keywords.txt"
  892|  8.39M|      {"br_if", TokenType::BrIf, Opcode::BrIf},
  893|  8.39M|#line 512 "src/lexer-keywords.txt"
  894|  8.39M|      {"i8x16.le_u", TokenType::Compare, Opcode::I8X16LeU},
  895|  8.39M|      {""},
  896|  8.39M|#line 507 "src/lexer-keywords.txt"
  897|  8.39M|      {"i8x16.ge_s", TokenType::Compare, Opcode::I8X16GeS},
  898|  8.39M|      {""},
  899|  8.39M|#line 511 "src/lexer-keywords.txt"
  900|  8.39M|      {"i8x16.le_s", TokenType::Compare, Opcode::I8X16LeS},
  901|  8.39M|      {""},
  902|  8.39M|#line 510 "src/lexer-keywords.txt"
  903|  8.39M|      {"i8x16.gt_u", TokenType::Compare, Opcode::I8X16GtU},
  904|  8.39M|#line 536 "src/lexer-keywords.txt"
  905|  8.39M|      {"import", TokenType::Import},
  906|  8.39M|#line 514 "src/lexer-keywords.txt"
  907|  8.39M|      {"i8x16.lt_u", TokenType::Compare, Opcode::I8X16LtU},
  908|  8.39M|      {""},
  909|  8.39M|#line 509 "src/lexer-keywords.txt"
  910|  8.39M|      {"i8x16.gt_s", TokenType::Compare, Opcode::I8X16GtS},
  911|  8.39M|      {""},
  912|  8.39M|#line 513 "src/lexer-keywords.txt"
  913|  8.39M|      {"i8x16.lt_s", TokenType::Compare, Opcode::I8X16LtS},
  914|  8.39M|      {""}, {""}, {""}, {""}, {""},
  915|  8.39M|#line 598 "src/lexer-keywords.txt"
  916|  8.39M|      {"v128.load", TokenType::Load, Opcode::V128Load},
  917|  8.39M|#line 158 "src/lexer-keywords.txt"
  918|  8.39M|      {"f64x2.extract_lane", TokenType::SimdLaneOp, Opcode::F64X2ExtractLane},
  919|  8.39M|      {""}, {""},
  920|  8.39M|#line 221 "src/lexer-keywords.txt"
  921|  8.39M|      {"i16x8.neg", TokenType::Unary, Opcode::I16X8Neg},
  922|  8.39M|      {""},
  923|  8.39M|#line 223 "src/lexer-keywords.txt"
  924|  8.39M|      {"i16x8.ne", TokenType::Compare, Opcode::I16X8Ne},
  925|  8.39M|#line 423 "src/lexer-keywords.txt"
  926|  8.39M|      {"i64.extend_i32_u", TokenType::Convert, Opcode::I64ExtendI32U},
  927|  8.39M|#line 466 "src/lexer-keywords.txt"
  928|  8.39M|      {"i64x2.extract_lane", TokenType::SimdLaneOp, Opcode::I64X2ExtractLane},
  929|  8.39M|#line 422 "src/lexer-keywords.txt"
  930|  8.39M|      {"i64.extend_i32_s", TokenType::Convert, Opcode::I64ExtendI32S},
  931|  8.39M|      {""}, {""},
  932|  8.39M|#line 148 "src/lexer-keywords.txt"
  933|  8.39M|      {"f64.sqrt", TokenType::Unary, Opcode::F64Sqrt},
  934|  8.39M|#line 86 "src/lexer-keywords.txt"
  935|  8.39M|      {"f32.sqrt", TokenType::Unary, Opcode::F32Sqrt},
  936|  8.39M|#line 211 "src/lexer-keywords.txt"
  937|  8.39M|      {"v128.load8x8_u", TokenType::Load, Opcode::V128Load8X8U},
  938|  8.39M|      {""},
  939|  8.39M|#line 210 "src/lexer-keywords.txt"
  940|  8.39M|      {"v128.load8x8_s", TokenType::Load, Opcode::V128Load8X8S},
  941|  8.39M|#line 611 "src/lexer-keywords.txt"
  942|  8.39M|      {"v128.load8_lane", TokenType::SimdLoadLane, Opcode::V128Load8Lane},
  943|  8.39M|#line 406 "src/lexer-keywords.txt"
  944|  8.39M|      {"i64.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I64AtomicRmwXchg},
  945|  8.39M|#line 269 "src/lexer-keywords.txt"
  946|  8.39M|      {"i32.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I32AtomicRmwXchg},
  947|  8.39M|      {""}, {""}, {""},
  948|  8.39M|#line 184 "src/lexer-keywords.txt"
  949|  8.39M|      {"f64x2", TokenType::F64X2},
  950|  8.39M|      {""}, {""},
  951|  8.39M|#line 610 "src/lexer-keywords.txt"
  952|  8.39M|      {"v128.load8_splat", TokenType::Load, Opcode::V128Load8Splat},
  953|  8.39M|      {""},
  954|  8.39M|#line 599 "src/lexer-keywords.txt"
  955|  8.39M|      {"v128.not", TokenType::Unary, Opcode::V128Not},
  956|  8.39M|#line 618 "src/lexer-keywords.txt"
  957|  8.39M|      {"v128.store64_lane", TokenType::SimdStoreLane, Opcode::V128Store64Lane},
  958|  8.39M|#line 495 "src/lexer-keywords.txt"
  959|  8.39M|      {"i64x2", TokenType::I64X2},
  960|  8.39M|#line 118 "src/lexer-keywords.txt"
  961|  8.39M|      {"f32x4.sqrt", TokenType::Unary, Opcode::F32X4Sqrt},
  962|  8.39M|      {""},
  963|  8.39M|#line 521 "src/lexer-keywords.txt"
  964|  8.39M|      {"i8x16.neg", TokenType::Unary, Opcode::I8X16Neg},
  965|  8.39M|      {""},
  966|  8.39M|#line 523 "src/lexer-keywords.txt"
  967|  8.39M|      {"i8x16.ne", TokenType::Compare, Opcode::I8X16Ne},
  968|  8.39M|#line 44 "src/lexer-keywords.txt"
  969|  8.39M|      {"data.drop", TokenType::DataDrop, Opcode::DataDrop},
  970|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
  971|  8.39M|#line 451 "src/lexer-keywords.txt"
  972|  8.39M|      {"i64.store16", TokenType::Store, Opcode::I64Store16},
  973|  8.39M|#line 308 "src/lexer-keywords.txt"
  974|  8.39M|      {"i32.store16", TokenType::Store, Opcode::I32Store16},
  975|  8.39M|      {""},
  976|  8.39M|#line 186 "src/lexer-keywords.txt"
  977|  8.39M|      {"funcref", Type::FuncRef},
  978|  8.39M|#line 196 "src/lexer-keywords.txt"
  979|  8.39M|      {"i16x8.add", TokenType::Binary, Opcode::I16X8Add},
  980|  8.39M|      {""}, {""}, {""},
  981|  8.39M|#line 597 "src/lexer-keywords.txt"
  982|  8.39M|      {"v128.const", TokenType::Const, Opcode::V128Const},
  983|  8.39M|      {""},
  984|  8.39M|#line 606 "src/lexer-keywords.txt"
  985|  8.39M|      {"v128.xor", TokenType::Binary, Opcode::V128Xor},
  986|  8.39M|      {""}, {""}, {""}, {""}, {""},
  987|  8.39M|#line 174 "src/lexer-keywords.txt"
  988|  8.39M|      {"f64x2.relaxed_min", TokenType::Binary, Opcode::F64X2RelaxedMin},
  989|  8.39M|      {""},
  990|  8.39M|#line 175 "src/lexer-keywords.txt"
  991|  8.39M|      {"f64x2.relaxed_nmadd", TokenType::Ternary, Opcode::F64X2RelaxedNmadd},
  992|  8.39M|      {""},
  993|  8.39M|#line 218 "src/lexer-keywords.txt"
  994|  8.39M|      {"i16x8.mul", TokenType::Binary, Opcode::I16X8Mul},
  995|  8.39M|      {""},
  996|  8.39M|#line 376 "src/lexer-keywords.txt"
  997|  8.39M|      {"i64.atomic.load16_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad16U},
  998|  8.39M|#line 247 "src/lexer-keywords.txt"
  999|  8.39M|      {"i32.atomic.load16_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad16U},
 1000|  8.39M|      {""}, {""}, {""},
 1001|  8.39M|#line 39 "src/lexer-keywords.txt"
 1002|  8.39M|      {"catch", TokenType::Catch, Opcode::Catch},
 1003|  8.39M|      {""}, {""},
 1004|  8.39M|#line 486 "src/lexer-keywords.txt"
 1005|  8.39M|      {"i64x2.shl", TokenType::Binary, Opcode::I64X2Shl},
 1006|  8.39M|      {""}, {""},
 1007|  8.39M|#line 500 "src/lexer-keywords.txt"
 1008|  8.39M|      {"i8x16.add", TokenType::Binary, Opcode::I8X16Add},
 1009|  8.39M|      {""},
 1010|  8.39M|#line 595 "src/lexer-keywords.txt"
 1011|  8.39M|      {"v128.and", TokenType::Binary, Opcode::V128And},
 1012|  8.39M|      {""}, {""}, {""}, {""},
 1013|  8.39M|#line 534 "src/lexer-keywords.txt"
 1014|  8.39M|      {"i8x16", TokenType::I8X16},
 1015|  8.39M|      {""}, {""},
 1016|  8.39M|#line 52 "src/lexer-keywords.txt"
 1017|  8.39M|      {"elem", TokenType::Elem},
 1018|  8.39M|      {""},
 1019|  8.39M|#line 57 "src/lexer-keywords.txt"
 1020|  8.39M|      {"externref", Type::ExternRef},
 1021|  8.39M|      {""}, {""},
 1022|  8.39M|#line 594 "src/lexer-keywords.txt"
 1023|  8.39M|      {"v128.andnot", TokenType::Binary, Opcode::V128Andnot},
 1024|  8.39M|      {""}, {""},
 1025|  8.39M|#line 384 "src/lexer-keywords.txt"
 1026|  8.39M|      {"i64.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16SubU},
 1027|  8.39M|#line 254 "src/lexer-keywords.txt"
 1028|  8.39M|      {"i32.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16SubU},
 1029|  8.39M|      {""},
 1030|  8.39M|#line 226 "src/lexer-keywords.txt"
 1031|  8.39M|      {"i16x8.replace_lane", TokenType::SimdLaneOp, Opcode::I16X8ReplaceLane},
 1032|  8.39M|      {""}, {""},
 1033|  8.39M|#line 159 "src/lexer-keywords.txt"
 1034|  8.39M|      {"f64x2.floor", TokenType::Unary, Opcode::F64X2Floor},
 1035|  8.39M|      {""}, {""},
 1036|  8.39M|#line 468 "src/lexer-keywords.txt"
 1037|  8.39M|      {"v128.load32x2_u", TokenType::Load, Opcode::V128Load32X2U},
 1038|  8.39M|#line 172 "src/lexer-keywords.txt"
 1039|  8.39M|      {"f64x2.relaxed_madd", TokenType::Ternary, Opcode::F64X2RelaxedMadd},
 1040|  8.39M|      {""}, {""},
 1041|  8.39M|#line 467 "src/lexer-keywords.txt"
 1042|  8.39M|      {"v128.load32x2_s", TokenType::Load, Opcode::V128Load32X2S},
 1043|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1044|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1045|  8.39M|#line 36 "src/lexer-keywords.txt"
 1046|  8.39M|      {"call_indirect", TokenType::CallIndirect, Opcode::CallIndirect},
 1047|  8.39M|      {""},
 1048|  8.39M|#line 526 "src/lexer-keywords.txt"
 1049|  8.39M|      {"i8x16.replace_lane", TokenType::SimdLaneOp, Opcode::I8X16ReplaceLane},
 1050|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1051|  8.39M|#line 165 "src/lexer-keywords.txt"
 1052|  8.39M|      {"f64x2.min", TokenType::Binary, Opcode::F64X2Min},
 1053|  8.39M|#line 383 "src/lexer-keywords.txt"
 1054|  8.39M|      {"i64.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16OrU},
 1055|  8.39M|#line 253 "src/lexer-keywords.txt"
 1056|  8.39M|      {"i32.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16OrU},
 1057|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1058|  8.39M|#line 224 "src/lexer-keywords.txt"
 1059|  8.39M|      {"i16x8.relaxed_laneselect", TokenType::Ternary, Opcode::I16X8RelaxedLaneSelect},
 1060|  8.39M|#line 197 "src/lexer-keywords.txt"
 1061|  8.39M|      {"i16x8.all_true", TokenType::Unary, Opcode::I16X8AllTrue},
 1062|  8.39M|      {""}, {""},
 1063|  8.39M|#line 21 "src/lexer-keywords.txt"
 1064|  8.39M|      {"after", TokenType::After},
 1065|  8.39M|#line 552 "src/lexer-keywords.txt"
 1066|  8.39M|      {"memory.size", TokenType::MemorySize, Opcode::MemorySize},
 1067|  8.39M|#line 173 "src/lexer-keywords.txt"
 1068|  8.39M|      {"f64x2.relaxed_max", TokenType::Binary, Opcode::F64X2RelaxedMax},
 1069|  8.39M|#line 380 "src/lexer-keywords.txt"
 1070|  8.39M|      {"i64.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AddU},
 1071|  8.39M|#line 250 "src/lexer-keywords.txt"
 1072|  8.39M|      {"i32.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AddU},
 1073|  8.39M|#line 399 "src/lexer-keywords.txt"
 1074|  8.39M|      {"i64.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XchgU},
 1075|  8.39M|#line 262 "src/lexer-keywords.txt"
 1076|  8.39M|      {"i32.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XchgU},
 1077|  8.39M|#line 232 "src/lexer-keywords.txt"
 1078|  8.39M|      {"i16x8.sub_sat_u", TokenType::Binary, Opcode::I16X8SubSatU},
 1079|  8.39M|      {""}, {""}, {""},
 1080|  8.39M|#line 231 "src/lexer-keywords.txt"
 1081|  8.39M|      {"i16x8.sub_sat_s", TokenType::Binary, Opcode::I16X8SubSatS},
 1082|  8.39M|      {""}, {""}, {""},
 1083|  8.39M|#line 381 "src/lexer-keywords.txt"
 1084|  8.39M|      {"i64.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AndU},
 1085|  8.39M|#line 251 "src/lexer-keywords.txt"
 1086|  8.39M|      {"i32.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AndU},
 1087|  8.39M|#line 347 "src/lexer-keywords.txt"
 1088|  8.39M|      {"i32x4.dot_i16x8_s", TokenType::Binary, Opcode::I32X4DotI16X8S},
 1089|  8.39M|      {""},
 1090|  8.39M|#line 389 "src/lexer-keywords.txt"
 1091|  8.39M|      {"i64.atomic.rmw32.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw32CmpxchgU},
 1092|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1093|  8.39M|#line 525 "src/lexer-keywords.txt"
 1094|  8.39M|      {"i8x16.relaxed_laneselect", TokenType::Ternary, Opcode::I8X16RelaxedLaneSelect},
 1095|  8.39M|#line 501 "src/lexer-keywords.txt"
 1096|  8.39M|      {"i8x16.all_true", TokenType::Unary, Opcode::I8X16AllTrue},
 1097|  8.39M|      {""}, {""}, {""}, {""},
 1098|  8.39M|#line 577 "src/lexer-keywords.txt"
 1099|  8.39M|      {"start", TokenType::Start},
 1100|  8.39M|      {""},
 1101|  8.39M|#line 123 "src/lexer-keywords.txt"
 1102|  8.39M|      {"f64.abs", TokenType::Unary, Opcode::F64Abs},
 1103|  8.39M|#line 61 "src/lexer-keywords.txt"
 1104|  8.39M|      {"f32.abs", TokenType::Unary, Opcode::F32Abs},
 1105|  8.39M|      {""},
 1106|  8.39M|#line 532 "src/lexer-keywords.txt"
 1107|  8.39M|      {"i8x16.sub_sat_u", TokenType::Binary, Opcode::I8X16SubSatU},
 1108|  8.39M|      {""}, {""}, {""},
 1109|  8.39M|#line 531 "src/lexer-keywords.txt"
 1110|  8.39M|      {"i8x16.sub_sat_s", TokenType::Binary, Opcode::I8X16SubSatS},
 1111|  8.39M|#line 616 "src/lexer-keywords.txt"
 1112|  8.39M|      {"v128.store16_lane", TokenType::SimdStoreLane, Opcode::V128Store16Lane},
 1113|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1114|  8.39M|#line 119 "src/lexer-keywords.txt"
 1115|  8.39M|      {"f32x4.sub", TokenType::Binary, Opcode::F32X4Sub},
 1116|  8.39M|      {""}, {""},
 1117|  8.39M|#line 91 "src/lexer-keywords.txt"
 1118|  8.39M|      {"f32x4.abs", TokenType::Unary, Opcode::F32X4Abs},
 1119|  8.39M|      {""},
 1120|  8.39M|#line 608 "src/lexer-keywords.txt"
 1121|  8.39M|      {"v128.load32_splat", TokenType::Load, Opcode::V128Load32Splat},
 1122|  8.39M|#line 562 "src/lexer-keywords.txt"
 1123|  8.39M|      {"param", TokenType::Param},
 1124|  8.39M|#line 357 "src/lexer-keywords.txt"
 1125|  8.39M|      {"i32x4.sub", TokenType::Binary, Opcode::I32X4Sub},
 1126|  8.39M|#line 96 "src/lexer-keywords.txt"
 1127|  8.39M|      {"f32x4.div", TokenType::Binary, Opcode::F32X4Div},
 1128|  8.39M|#line 602 "src/lexer-keywords.txt"
 1129|  8.39M|      {"v128.load32_zero", TokenType::Load, Opcode::V128Load32Zero},
 1130|  8.39M|#line 322 "src/lexer-keywords.txt"
 1131|  8.39M|      {"i32x4.abs", TokenType::Unary, Opcode::I32X4Abs},
 1132|  8.39M|#line 34 "src/lexer-keywords.txt"
 1133|  8.39M|      {"br_table", TokenType::BrTable, Opcode::BrTable},
 1134|  8.39M|      {""}, {""}, {""},
 1135|  8.39M|#line 195 "src/lexer-keywords.txt"
 1136|  8.39M|      {"i16x8.add_sat_u", TokenType::Binary, Opcode::I16X8AddSatU},
 1137|  8.39M|      {""}, {""}, {""},
 1138|  8.39M|#line 194 "src/lexer-keywords.txt"
 1139|  8.39M|      {"i16x8.add_sat_s", TokenType::Binary, Opcode::I16X8AddSatS},
 1140|  8.39M|      {""},
 1141|  8.39M|#line 111 "src/lexer-keywords.txt"
 1142|  8.39M|      {"f32x4.pmin", TokenType::Binary, Opcode::F32X4PMin},
 1143|  8.39M|#line 31 "src/lexer-keywords.txt"
 1144|  8.39M|      {"binary", TokenType::Bin},
 1145|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1146|  8.39M|#line 463 "src/lexer-keywords.txt"
 1147|  8.39M|      {"i64.trunc_sat_f64_u", TokenType::Convert, Opcode::I64TruncSatF64U},
 1148|  8.39M|#line 319 "src/lexer-keywords.txt"
 1149|  8.39M|      {"i32.trunc_sat_f64_u", TokenType::Convert, Opcode::I32TruncSatF64U},
 1150|  8.39M|#line 385 "src/lexer-keywords.txt"
 1151|  8.39M|      {"i64.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XchgU},
 1152|  8.39M|#line 255 "src/lexer-keywords.txt"
 1153|  8.39M|      {"i32.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XchgU},
 1154|  8.39M|#line 462 "src/lexer-keywords.txt"
 1155|  8.39M|      {"i64.trunc_sat_f64_s", TokenType::Convert, Opcode::I64TruncSatF64S},
 1156|  8.39M|#line 318 "src/lexer-keywords.txt"
 1157|  8.39M|      {"i32.trunc_sat_f64_s", TokenType::Convert, Opcode::I32TruncSatF64S},
 1158|  8.39M|      {""}, {""},
 1159|  8.39M|#line 613 "src/lexer-keywords.txt"
 1160|  8.39M|      {"v128.load32_lane", TokenType::SimdLoadLane, Opcode::V128Load32Lane},
 1161|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1162|  8.39M|#line 499 "src/lexer-keywords.txt"
 1163|  8.39M|      {"i8x16.add_sat_u", TokenType::Binary, Opcode::I8X16AddSatU},
 1164|  8.39M|#line 377 "src/lexer-keywords.txt"
 1165|  8.39M|      {"i64.atomic.load32_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad32U},
 1166|  8.39M|      {""},
 1167|  8.39M|#line 615 "src/lexer-keywords.txt"
 1168|  8.39M|      {"v128.store8_lane", TokenType::SimdStoreLane, Opcode::V128Store8Lane},
 1169|  8.39M|#line 498 "src/lexer-keywords.txt"
 1170|  8.39M|      {"i8x16.add_sat_s", TokenType::Binary, Opcode::I8X16AddSatS},
 1171|  8.39M|      {""},
 1172|  8.39M|#line 386 "src/lexer-keywords.txt"
 1173|  8.39M|      {"i64.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XorU},
 1174|  8.39M|#line 256 "src/lexer-keywords.txt"
 1175|  8.39M|      {"i32.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XorU},
 1176|  8.39M|      {""},
 1177|  8.39M|#line 192 "src/lexer-keywords.txt"
 1178|  8.39M|      {"global", TokenType::Global},
 1179|  8.39M|#line 215 "src/lexer-keywords.txt"
 1180|  8.39M|      {"i16x8.max_u", TokenType::Binary, Opcode::I16X8MaxU},
 1181|  8.39M|      {""},
 1182|  8.39M|#line 214 "src/lexer-keywords.txt"
 1183|  8.39M|      {"i16x8.max_s", TokenType::Binary, Opcode::I16X8MaxS},
 1184|  8.39M|      {""}, {""}, {""}, {""},
 1185|  8.39M|#line 488 "src/lexer-keywords.txt"
 1186|  8.39M|      {"i64x2.shr_u", TokenType::Binary, Opcode::I64X2ShrU},
 1187|  8.39M|      {""},
 1188|  8.39M|#line 487 "src/lexer-keywords.txt"
 1189|  8.39M|      {"i64x2.shr_s", TokenType::Binary, Opcode::I64X2ShrS},
 1190|  8.39M|      {""},
 1191|  8.39M|#line 549 "src/lexer-keywords.txt"
 1192|  8.39M|      {"memory.fill", TokenType::MemoryFill, Opcode::MemoryFill},
 1193|  8.39M|      {""}, {""}, {""}, {""},
 1194|  8.39M|#line 326 "src/lexer-keywords.txt"
 1195|  8.39M|      {"i32x4.relaxed_dot_i8x16_i7x16_add_s", TokenType::Ternary, Opcode::I32X4DotI8X16I7X16AddS},
 1196|  8.39M|#line 41 "src/lexer-keywords.txt"
 1197|  8.39M|      {"catch_ref", TokenType::CatchRef},
 1198|  8.39M|      {""}, {""}, {""},
 1199|  8.39M|#line 579 "src/lexer-keywords.txt"
 1200|  8.39M|      {"table.copy", TokenType::TableCopy, Opcode::TableCopy},
 1201|  8.39M|      {""},
 1202|  8.39M|#line 227 "src/lexer-keywords.txt"
 1203|  8.39M|      {"i16x8.shl", TokenType::Binary, Opcode::I16X8Shl},
 1204|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1205|  8.39M|#line 516 "src/lexer-keywords.txt"
 1206|  8.39M|      {"i8x16.max_u", TokenType::Binary, Opcode::I8X16MaxU},
 1207|  8.39M|      {""},
 1208|  8.39M|#line 515 "src/lexer-keywords.txt"
 1209|  8.39M|      {"i8x16.max_s", TokenType::Binary, Opcode::I8X16MaxS},
 1210|  8.39M|      {""}, {""},
 1211|  8.39M|#line 576 "src/lexer-keywords.txt"
 1212|  8.39M|      {"shared", TokenType::Shared},
 1213|  8.39M|#line 130 "src/lexer-keywords.txt"
 1214|  8.39M|      {"f64.convert_i64_u", TokenType::Convert, Opcode::F64ConvertI64U},
 1215|  8.39M|#line 68 "src/lexer-keywords.txt"
 1216|  8.39M|      {"f32.convert_i64_u", TokenType::Convert, Opcode::F32ConvertI64U},
 1217|  8.39M|      {""}, {""},
 1218|  8.39M|#line 129 "src/lexer-keywords.txt"
 1219|  8.39M|      {"f64.convert_i64_s", TokenType::Convert, Opcode::F64ConvertI64S},
 1220|  8.39M|#line 67 "src/lexer-keywords.txt"
 1221|  8.39M|      {"f32.convert_i64_s", TokenType::Convert, Opcode::F32ConvertI64S},
 1222|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1223|  8.39M|#line 60 "src/lexer-keywords.txt"
 1224|  8.39M|      {"export", TokenType::Export},
 1225|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1226|  8.39M|#line 527 "src/lexer-keywords.txt"
 1227|  8.39M|      {"i8x16.shl", TokenType::Binary, Opcode::I8X16Shl},
 1228|  8.39M|#line 553 "src/lexer-keywords.txt"
 1229|  8.39M|      {"memory", TokenType::Memory},
 1230|  8.39M|#line 593 "src/lexer-keywords.txt"
 1231|  8.39M|      {"unreachable", TokenType::Unreachable, Opcode::Unreachable},
 1232|  8.39M|      {""},
 1233|  8.39M|#line 177 "src/lexer-keywords.txt"
 1234|  8.39M|      {"f64x2.splat", TokenType::Unary, Opcode::F64X2Splat},
 1235|  8.39M|#line 110 "src/lexer-keywords.txt"
 1236|  8.39M|      {"f32x4.pmax", TokenType::Binary, Opcode::F32X4PMax},
 1237|  8.39M|#line 372 "src/lexer-keywords.txt"
 1238|  8.39M|      {"i32x4.trunc_sat_f64x2_u_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2UZero},
 1239|  8.39M|      {""},
 1240|  8.39M|#line 371 "src/lexer-keywords.txt"
 1241|  8.39M|      {"i32x4.trunc_sat_f64x2_s_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2SZero},
 1242|  8.39M|      {""},
 1243|  8.39M|#line 190 "src/lexer-keywords.txt"
 1244|  8.39M|      {"global.get", TokenType::GlobalGet, Opcode::GlobalGet},
 1245|  8.39M|#line 489 "src/lexer-keywords.txt"
 1246|  8.39M|      {"i64x2.splat", TokenType::Unary, Opcode::I64X2Splat},
 1247|  8.39M|#line 191 "src/lexer-keywords.txt"
 1248|  8.39M|      {"global.set", TokenType::GlobalSet, Opcode::GlobalSet},
 1249|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1250|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1251|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1252|  8.39M|#line 409 "src/lexer-keywords.txt"
 1253|  8.39M|      {"i64.atomic.store32", TokenType::AtomicStore, Opcode::I64AtomicStore32},
 1254|  8.39M|      {""}, {""},
 1255|  8.39M|#line 59 "src/lexer-keywords.txt"
 1256|  8.39M|      {"exnref", Type::ExnRef},
 1257|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1258|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1259|  8.39M|#line 609 "src/lexer-keywords.txt"
 1260|  8.39M|      {"v128.load64_splat", TokenType::Load, Opcode::V128Load64Splat},
 1261|  8.39M|#line 617 "src/lexer-keywords.txt"
 1262|  8.39M|      {"v128.store32_lane", TokenType::SimdStoreLane, Opcode::V128Store32Lane},
 1263|  8.39M|#line 178 "src/lexer-keywords.txt"
 1264|  8.39M|      {"f64x2.sqrt", TokenType::Unary, Opcode::F64X2Sqrt},
 1265|  8.39M|#line 588 "src/lexer-keywords.txt"
 1266|  8.39M|      {"throw", TokenType::Throw, Opcode::Throw},
 1267|  8.39M|#line 603 "src/lexer-keywords.txt"
 1268|  8.39M|      {"v128.load64_zero", TokenType::Load, Opcode::V128Load64Zero},
 1269|  8.39M|      {""}, {""}, {""}, {""},
 1270|  8.39M|#line 37 "src/lexer-keywords.txt"
 1271|  8.39M|      {"call_ref", TokenType::CallRef, Opcode::CallRef},
 1272|  8.39M|      {""}, {""},
 1273|  8.39M|#line 551 "src/lexer-keywords.txt"
 1274|  8.39M|      {"memory.init", TokenType::MemoryInit, Opcode::MemoryInit},
 1275|  8.39M|#line 416 "src/lexer-keywords.txt"
 1276|  8.39M|      {"i64.div_u", TokenType::Binary, Opcode::I64DivU},
 1277|  8.39M|#line 278 "src/lexer-keywords.txt"
 1278|  8.39M|      {"i32.div_u", TokenType::Binary, Opcode::I32DivU},
 1279|  8.39M|#line 415 "src/lexer-keywords.txt"
 1280|  8.39M|      {"i64.div_s", TokenType::Binary, Opcode::I64DivS},
 1281|  8.39M|#line 277 "src/lexer-keywords.txt"
 1282|  8.39M|      {"i32.div_s", TokenType::Binary, Opcode::I32DivS},
 1283|  8.39M|      {""}, {""}, {""}, {""},
 1284|  8.39M|#line 418 "src/lexer-keywords.txt"
 1285|  8.39M|      {"i64.eqz", TokenType::Convert, Opcode::I64Eqz},
 1286|  8.39M|#line 280 "src/lexer-keywords.txt"
 1287|  8.39M|      {"i32.eqz", TokenType::Convert, Opcode::I32Eqz},
 1288|  8.39M|      {""}, {""},
 1289|  8.39M|#line 589 "src/lexer-keywords.txt"
 1290|  8.39M|      {"throw_ref", TokenType::ThrowRef, Opcode::ThrowRef},
 1291|  8.39M|      {""},
 1292|  8.39M|#line 203 "src/lexer-keywords.txt"
 1293|  8.39M|      {"i16x8.extract_lane_u", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneU},
 1294|  8.39M|      {""},
 1295|  8.39M|#line 202 "src/lexer-keywords.txt"
 1296|  8.39M|      {"i16x8.extract_lane_s", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneS},
 1297|  8.39M|      {""}, {""},
 1298|  8.39M|#line 614 "src/lexer-keywords.txt"
 1299|  8.39M|      {"v128.load64_lane", TokenType::SimdLoadLane, Opcode::V128Load64Lane},
 1300|  8.39M|#line 396 "src/lexer-keywords.txt"
 1301|  8.39M|      {"i64.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw8CmpxchgU},
 1302|  8.39M|#line 259 "src/lexer-keywords.txt"
 1303|  8.39M|      {"i32.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw8CmpxchgU},
 1304|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1305|  8.39M|#line 408 "src/lexer-keywords.txt"
 1306|  8.39M|      {"i64.atomic.store16", TokenType::AtomicStore, Opcode::I64AtomicStore16},
 1307|  8.39M|#line 271 "src/lexer-keywords.txt"
 1308|  8.39M|      {"i32.atomic.store16", TokenType::AtomicStore, Opcode::I32AtomicStore16},
 1309|  8.39M|      {""}, {""},
 1310|  8.39M|#line 591 "src/lexer-keywords.txt"
 1311|  8.39M|      {"try_table", TokenType::TryTable, Opcode::TryTable},
 1312|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1313|  8.39M|#line 601 "src/lexer-keywords.txt"
 1314|  8.39M|      {"v128.any_true", TokenType::Unary, Opcode::V128AnyTrue},
 1315|  8.39M|      {""},
 1316|  8.39M|#line 506 "src/lexer-keywords.txt"
 1317|  8.39M|      {"i8x16.extract_lane_u", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneU},
 1318|  8.39M|#line 366 "src/lexer-keywords.txt"
 1319|  8.39M|      {"i32x4.trunc_sat_f32x4_u", TokenType::Unary, Opcode::I32X4TruncSatF32X4U},
 1320|  8.39M|#line 505 "src/lexer-keywords.txt"
 1321|  8.39M|      {"i8x16.extract_lane_s", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneS},
 1322|  8.39M|      {""}, {""},
 1323|  8.39M|#line 365 "src/lexer-keywords.txt"
 1324|  8.39M|      {"i32x4.trunc_sat_f32x4_s", TokenType::Unary, Opcode::I32X4TruncSatF32X4S},
 1325|  8.39M|      {""}, {""}, {""}, {""},
 1326|  8.39M|#line 49 "src/lexer-keywords.txt"
 1327|  8.39M|      {"drop", TokenType::Drop, Opcode::Drop},
 1328|  8.39M|      {""}, {""}, {""},
 1329|  8.39M|#line 582 "src/lexer-keywords.txt"
 1330|  8.39M|      {"table.grow", TokenType::TableGrow, Opcode::TableGrow},
 1331|  8.39M|      {""}, {""},
 1332|  8.39M|#line 571 "src/lexer-keywords.txt"
 1333|  8.39M|      {"rethrow", TokenType::Rethrow, Opcode::Rethrow},
 1334|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1335|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1336|  8.39M|      {""},
 1337|  8.39M|#line 229 "src/lexer-keywords.txt"
 1338|  8.39M|      {"i16x8.shr_u", TokenType::Binary, Opcode::I16X8ShrU},
 1339|  8.39M|#line 217 "src/lexer-keywords.txt"
 1340|  8.39M|      {"i16x8.min_u", TokenType::Binary, Opcode::I16X8MinU},
 1341|  8.39M|#line 228 "src/lexer-keywords.txt"
 1342|  8.39M|      {"i16x8.shr_s", TokenType::Binary, Opcode::I16X8ShrS},
 1343|  8.39M|#line 216 "src/lexer-keywords.txt"
 1344|  8.39M|      {"i16x8.min_s", TokenType::Binary, Opcode::I16X8MinS},
 1345|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1346|  8.39M|#line 403 "src/lexer-keywords.txt"
 1347|  8.39M|      {"i64.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmwCmpxchg},
 1348|  8.39M|#line 266 "src/lexer-keywords.txt"
 1349|  8.39M|      {"i32.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmwCmpxchg},
 1350|  8.39M|      {""},
 1351|  8.39M|#line 121 "src/lexer-keywords.txt"
 1352|  8.39M|      {"f32x4.demote_f64x2_zero", TokenType::Unary, Opcode::F32X4DemoteF64X2Zero},
 1353|  8.39M|      {""}, {""},
 1354|  8.39M|#line 42 "src/lexer-keywords.txt"
 1355|  8.39M|      {"catch_all_ref", TokenType::CatchAllRef},
 1356|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1357|  8.39M|      {""}, {""}, {""}, {""},
 1358|  8.39M|#line 529 "src/lexer-keywords.txt"
 1359|  8.39M|      {"i8x16.shr_u", TokenType::Binary, Opcode::I8X16ShrU},
 1360|  8.39M|#line 518 "src/lexer-keywords.txt"
 1361|  8.39M|      {"i8x16.min_u", TokenType::Binary, Opcode::I8X16MinU},
 1362|  8.39M|#line 528 "src/lexer-keywords.txt"
 1363|  8.39M|      {"i8x16.shr_s", TokenType::Binary, Opcode::I8X16ShrS},
 1364|  8.39M|#line 517 "src/lexer-keywords.txt"
 1365|  8.39M|      {"i8x16.min_s", TokenType::Binary, Opcode::I8X16MinS},
 1366|  8.39M|      {""}, {""}, {""},
 1367|  8.39M|#line 26 "src/lexer-keywords.txt"
 1368|  8.39M|      {"assert_return", TokenType::AssertReturn},
 1369|  8.39M|#line 550 "src/lexer-keywords.txt"
 1370|  8.39M|      {"memory.grow", TokenType::MemoryGrow, Opcode::MemoryGrow},
 1371|  8.39M|      {""}, {""}, {""}, {""},
 1372|  8.39M|#line 398 "src/lexer-keywords.txt"
 1373|  8.39M|      {"i64.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8SubU},
 1374|  8.39M|#line 261 "src/lexer-keywords.txt"
 1375|  8.39M|      {"i32.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8SubU},
 1376|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1377|  8.39M|      {""}, {""},
 1378|  8.39M|#line 198 "src/lexer-keywords.txt"
 1379|  8.39M|      {"i16x8.avgr_u", TokenType::Binary, Opcode::I16X8AvgrU},
 1380|  8.39M|#line 230 "src/lexer-keywords.txt"
 1381|  8.39M|      {"i16x8.splat", TokenType::Unary, Opcode::I16X8Splat},
 1382|  8.39M|      {""}, {""}, {""},
 1383|  8.39M|#line 340 "src/lexer-keywords.txt"
 1384|  8.39M|      {"v128.load16x4_u", TokenType::Load, Opcode::V128Load16X4U},
 1385|  8.39M|      {""},
 1386|  8.39M|#line 558 "src/lexer-keywords.txt"
 1387|  8.39M|      {"nop", TokenType::Nop, Opcode::Nop},
 1388|  8.39M|      {""},
 1389|  8.39M|#line 339 "src/lexer-keywords.txt"
 1390|  8.39M|      {"v128.load16x4_s", TokenType::Load, Opcode::V128Load16X4S},
 1391|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1392|  8.39M|#line 179 "src/lexer-keywords.txt"
 1393|  8.39M|      {"f64x2.sub", TokenType::Binary, Opcode::F64X2Sub},
 1394|  8.39M|      {""}, {""},
 1395|  8.39M|#line 153 "src/lexer-keywords.txt"
 1396|  8.39M|      {"f64x2.abs", TokenType::Unary, Opcode::F64X2Abs},
 1397|  8.39M|      {""}, {""}, {""},
 1398|  8.39M|#line 490 "src/lexer-keywords.txt"
 1399|  8.39M|      {"i64x2.sub", TokenType::Binary, Opcode::I64X2Sub},
 1400|  8.39M|#line 156 "src/lexer-keywords.txt"
 1401|  8.39M|      {"f64x2.div", TokenType::Binary, Opcode::F64X2Div},
 1402|  8.39M|      {""},
 1403|  8.39M|#line 476 "src/lexer-keywords.txt"
 1404|  8.39M|      {"i64x2.abs", TokenType::Unary, Opcode::I64X2Abs},
 1405|  8.39M|#line 502 "src/lexer-keywords.txt"
 1406|  8.39M|      {"i8x16.avgr_u", TokenType::Binary, Opcode::I8X16AvgrU},
 1407|  8.39M|#line 530 "src/lexer-keywords.txt"
 1408|  8.39M|      {"i8x16.splat", TokenType::Unary, Opcode::I8X16Splat},
 1409|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1410|  8.39M|#line 171 "src/lexer-keywords.txt"
 1411|  8.39M|      {"f64x2.pmin", TokenType::Binary, Opcode::F64X2PMin},
 1412|  8.39M|      {""}, {""},
 1413|  8.39M|#line 544 "src/lexer-keywords.txt"
 1414|  8.39M|      {"loop", TokenType::Loop, Opcode::Loop},
 1415|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1416|  8.39M|#line 461 "src/lexer-keywords.txt"
 1417|  8.39M|      {"i64.trunc_sat_f32_u", TokenType::Convert, Opcode::I64TruncSatF32U},
 1418|  8.39M|#line 317 "src/lexer-keywords.txt"
 1419|  8.39M|      {"i32.trunc_sat_f32_u", TokenType::Convert, Opcode::I32TruncSatF32U},
 1420|  8.39M|#line 133 "src/lexer-keywords.txt"
 1421|  8.39M|      {"f64.eq", TokenType::Compare, Opcode::F64Eq},
 1422|  8.39M|#line 72 "src/lexer-keywords.txt"
 1423|  8.39M|      {"f32.eq", TokenType::Compare, Opcode::F32Eq},
 1424|  8.39M|#line 460 "src/lexer-keywords.txt"
 1425|  8.39M|      {"i64.trunc_sat_f32_s", TokenType::Convert, Opcode::I64TruncSatF32S},
 1426|  8.39M|#line 316 "src/lexer-keywords.txt"
 1427|  8.39M|      {"i32.trunc_sat_f32_s", TokenType::Convert, Opcode::I32TruncSatF32S},
 1428|  8.39M|      {""}, {""}, {""},
 1429|  8.39M|#line 417 "src/lexer-keywords.txt"
 1430|  8.39M|      {"i64.eq", TokenType::Compare, Opcode::I64Eq},
 1431|  8.39M|#line 279 "src/lexer-keywords.txt"
 1432|  8.39M|      {"i32.eq", TokenType::Compare, Opcode::I32Eq},
 1433|  8.39M|#line 325 "src/lexer-keywords.txt"
 1434|  8.39M|      {"i32x4.bitmask", TokenType::Unary, Opcode::I32X4Bitmask},
 1435|  8.39M|      {""}, {""}, {""}, {""},
 1436|  8.39M|#line 442 "src/lexer-keywords.txt"
 1437|  8.39M|      {"i64.popcnt", TokenType::Unary, Opcode::I64Popcnt},
 1438|  8.39M|#line 299 "src/lexer-keywords.txt"
 1439|  8.39M|      {"i32.popcnt", TokenType::Unary, Opcode::I32Popcnt},
 1440|  8.39M|      {""}, {""},
 1441|  8.39M|#line 382 "src/lexer-keywords.txt"
 1442|  8.39M|      {"i64.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw16CmpxchgU},
 1443|  8.39M|#line 252 "src/lexer-keywords.txt"
 1444|  8.39M|      {"i32.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw16CmpxchgU},
 1445|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1446|  8.39M|      {""}, {""}, {""}, {""},
 1447|  8.39M|#line 97 "src/lexer-keywords.txt"
 1448|  8.39M|      {"f32x4.eq", TokenType::Compare, Opcode::F32X4Eq},
 1449|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1450|  8.39M|#line 327 "src/lexer-keywords.txt"
 1451|  8.39M|      {"i32x4.eq", TokenType::Compare, Opcode::I32X4Eq},
 1452|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1453|  8.39M|#line 482 "src/lexer-keywords.txt"
 1454|  8.39M|      {"i64x2.extend_low_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendLowI32X4U},
 1455|  8.39M|      {""},
 1456|  8.39M|#line 480 "src/lexer-keywords.txt"
 1457|  8.39M|      {"i64x2.extend_low_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendLowI32X4S},
 1458|  8.39M|#line 522 "src/lexer-keywords.txt"
 1459|  8.39M|      {"i8x16.popcnt", TokenType::Unary, Opcode::I8X16Popcnt},
 1460|  8.39M|      {""}, {""},
 1461|  8.39M|#line 607 "src/lexer-keywords.txt"
 1462|  8.39M|      {"v128.load16_splat", TokenType::Load, Opcode::V128Load16Splat},
 1463|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1464|  8.39M|#line 128 "src/lexer-keywords.txt"
 1465|  8.39M|      {"f64.convert_i32_u", TokenType::Convert, Opcode::F64ConvertI32U},
 1466|  8.39M|#line 66 "src/lexer-keywords.txt"
 1467|  8.39M|      {"f32.convert_i32_u", TokenType::Convert, Opcode::F32ConvertI32U},
 1468|  8.39M|      {""}, {""},
 1469|  8.39M|#line 127 "src/lexer-keywords.txt"
 1470|  8.39M|      {"f64.convert_i32_s", TokenType::Convert, Opcode::F64ConvertI32S},
 1471|  8.39M|#line 65 "src/lexer-keywords.txt"
 1472|  8.39M|      {"f32.convert_i32_s", TokenType::Convert, Opcode::F32ConvertI32S},
 1473|  8.39M|      {""},
 1474|  8.39M|#line 368 "src/lexer-keywords.txt"
 1475|  8.39M|      {"i32x4.extend_high_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendHighI16X8U},
 1476|  8.39M|      {""},
 1477|  8.39M|#line 367 "src/lexer-keywords.txt"
 1478|  8.39M|      {"i32x4.extend_high_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendHighI16X8S},
 1479|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1480|  8.39M|      {""}, {""},
 1481|  8.39M|#line 170 "src/lexer-keywords.txt"
 1482|  8.39M|      {"f64x2.pmax", TokenType::Binary, Opcode::F64X2PMax},
 1483|  8.39M|      {""}, {""}, {""}, {""},
 1484|  8.39M|#line 612 "src/lexer-keywords.txt"
 1485|  8.39M|      {"v128.load16_lane", TokenType::SimdLoadLane, Opcode::V128Load16Lane},
 1486|  8.39M|      {""}, {""},
 1487|  8.39M|#line 619 "src/lexer-keywords.txt"
 1488|  8.39M|      {"i8x16.shuffle", TokenType::SimdShuffleOp, Opcode::I8X16Shuffle},
 1489|  8.39M|      {""}, {""},
 1490|  8.39M|#line 359 "src/lexer-keywords.txt"
 1491|  8.39M|      {"i32x4.extadd_pairwise_i16x8_u", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8U},
 1492|  8.39M|      {""},
 1493|  8.39M|#line 358 "src/lexer-keywords.txt"
 1494|  8.39M|      {"i32x4.extadd_pairwise_i16x8_s", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8S},
 1495|  8.39M|      {""}, {""},
 1496|  8.39M|#line 25 "src/lexer-keywords.txt"
 1497|  8.39M|      {"assert_malformed", TokenType::AssertMalformed},
 1498|  8.39M|      {""}, {""}, {""},
 1499|  8.39M|#line 51 "src/lexer-keywords.txt"
 1500|  8.39M|      {"elem.drop", TokenType::ElemDrop, Opcode::ElemDrop},
 1501|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1502|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1503|  8.39M|#line 493 "src/lexer-keywords.txt"
 1504|  8.39M|      {"i64x2.extmul_low_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4U},
 1505|  8.39M|#line 524 "src/lexer-keywords.txt"
 1506|  8.39M|      {"i8x16.relaxed_swizzle", TokenType::Binary, Opcode::I8X16RelaxedSwizzle},
 1507|  8.39M|#line 491 "src/lexer-keywords.txt"
 1508|  8.39M|      {"i64x2.extmul_low_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4S},
 1509|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1510|  8.39M|#line 370 "src/lexer-keywords.txt"
 1511|  8.39M|      {"i32x4.extend_low_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendLowI16X8U},
 1512|  8.39M|      {""},
 1513|  8.39M|#line 369 "src/lexer-keywords.txt"
 1514|  8.39M|      {"i32x4.extend_low_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendLowI16X8S},
 1515|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1516|  8.39M|#line 363 "src/lexer-keywords.txt"
 1517|  8.39M|      {"i32x4.extmul_high_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8U},
 1518|  8.39M|      {""},
 1519|  8.39M|#line 361 "src/lexer-keywords.txt"
 1520|  8.39M|      {"i32x4.extmul_high_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8S},
 1521|  8.39M|      {""},
 1522|  8.39M|#line 147 "src/lexer-keywords.txt"
 1523|  8.39M|      {"f64.reinterpret_i64", TokenType::Convert, Opcode::F64ReinterpretI64},
 1524|  8.39M|      {""}, {""},
 1525|  8.39M|#line 321 "src/lexer-keywords.txt"
 1526|  8.39M|      {"i32.wrap_i64", TokenType::Convert, Opcode::I32WrapI64},
 1527|  8.39M|      {""}, {""}, {""}, {""},
 1528|  8.39M|#line 620 "src/lexer-keywords.txt"
 1529|  8.39M|      {"i8x16.swizzle", TokenType::Binary, Opcode::I8X16Swizzle},
 1530|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1531|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1532|  8.39M|#line 132 "src/lexer-keywords.txt"
 1533|  8.39M|      {"f64.div", TokenType::Binary, Opcode::F64Div},
 1534|  8.39M|#line 71 "src/lexer-keywords.txt"
 1535|  8.39M|      {"f32.div", TokenType::Binary, Opcode::F32Div},
 1536|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1537|  8.39M|#line 233 "src/lexer-keywords.txt"
 1538|  8.39M|      {"i16x8.sub", TokenType::Binary, Opcode::I16X8Sub},
 1539|  8.39M|      {""}, {""},
 1540|  8.39M|#line 193 "src/lexer-keywords.txt"
 1541|  8.39M|      {"i16x8.abs", TokenType::Unary, Opcode::I16X8Abs},
 1542|  8.39M|      {""},
 1543|  8.39M|#line 561 "src/lexer-keywords.txt"
 1544|  8.39M|      {"pagesize", TokenType::PageSize},
 1545|  8.39M|      {""}, {""},
 1546|  8.39M|#line 95 "src/lexer-keywords.txt"
 1547|  8.39M|      {"f32x4.convert_i32x4_u", TokenType::Unary, Opcode::F32X4ConvertI32X4U},
 1548|  8.39M|      {""},
 1549|  8.39M|#line 94 "src/lexer-keywords.txt"
 1550|  8.39M|      {"f32x4.convert_i32x4_s", TokenType::Unary, Opcode::F32X4ConvertI32X4S},
 1551|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1552|  8.39M|      {""}, {""},
 1553|  8.39M|#line 362 "src/lexer-keywords.txt"
 1554|  8.39M|      {"i32x4.extmul_low_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8U},
 1555|  8.39M|      {""},
 1556|  8.39M|#line 360 "src/lexer-keywords.txt"
 1557|  8.39M|      {"i32x4.extmul_low_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8S},
 1558|  8.39M|      {""}, {""},
 1559|  8.39M|#line 131 "src/lexer-keywords.txt"
 1560|  8.39M|      {"f64.copysign", TokenType::Binary, Opcode::F64Copysign},
 1561|  8.39M|#line 69 "src/lexer-keywords.txt"
 1562|  8.39M|      {"f32.copysign", TokenType::Binary, Opcode::F32Copysign},
 1563|  8.39M|#line 533 "src/lexer-keywords.txt"
 1564|  8.39M|      {"i8x16.sub", TokenType::Binary, Opcode::I8X16Sub},
 1565|  8.39M|      {""}, {""},
 1566|  8.39M|#line 497 "src/lexer-keywords.txt"
 1567|  8.39M|      {"i8x16.abs", TokenType::Unary, Opcode::I8X16Abs},
 1568|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1569|  8.39M|      {""}, {""},
 1570|  8.39M|#line 225 "src/lexer-keywords.txt"
 1571|  8.39M|      {"i16x8.relaxed_q15mulr_s", TokenType::Binary, Opcode::I16X8RelaxedQ15mulrS},
 1572|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1573|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1574|  8.39M|#line 200 "src/lexer-keywords.txt"
 1575|  8.39M|      {"i16x8.relaxed_dot_i8x16_i7x16_s", TokenType::Binary, Opcode::I16X8DotI8X16I7X16S},
 1576|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1577|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1578|  8.39M|#line 443 "src/lexer-keywords.txt"
 1579|  8.39M|      {"i64.reinterpret_f64", TokenType::Convert, Opcode::I64ReinterpretF64},
 1580|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1581|  8.39M|      {""}, {""}, {""},
 1582|  8.39M|#line 244 "src/lexer-keywords.txt"
 1583|  8.39M|      {"i16x8.extend_low_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendLowI8X16U},
 1584|  8.39M|      {""},
 1585|  8.39M|#line 243 "src/lexer-keywords.txt"
 1586|  8.39M|      {"i16x8.extend_low_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendLowI8X16S},
 1587|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1588|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1589|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1590|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1591|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1592|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1593|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1594|  8.39M|#line 220 "src/lexer-keywords.txt"
 1595|  8.39M|      {"i16x8.narrow_i32x4_u", TokenType::Binary, Opcode::I16X8NarrowI32X4U},
 1596|  8.39M|      {""},
 1597|  8.39M|#line 219 "src/lexer-keywords.txt"
 1598|  8.39M|      {"i16x8.narrow_i32x4_s", TokenType::Binary, Opcode::I16X8NarrowI32X4S},
 1599|  8.39M|      {""}, {""},
 1600|  8.39M|#line 238 "src/lexer-keywords.txt"
 1601|  8.39M|      {"i16x8.extmul_low_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16U},
 1602|  8.39M|      {""},
 1603|  8.39M|#line 236 "src/lexer-keywords.txt"
 1604|  8.39M|      {"i16x8.extmul_low_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16S},
 1605|  8.39M|      {""}, {""}, {""},
 1606|  8.39M|#line 548 "src/lexer-keywords.txt"
 1607|  8.39M|      {"memory.copy", TokenType::MemoryCopy, Opcode::MemoryCopy},
 1608|  8.39M|      {""},
 1609|  8.39M|#line 479 "src/lexer-keywords.txt"
 1610|  8.39M|      {"i64x2.bitmask", TokenType::Unary, Opcode::I64X2Bitmask},
 1611|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1612|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1613|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1614|  8.39M|#line 157 "src/lexer-keywords.txt"
 1615|  8.39M|      {"f64x2.eq", TokenType::Compare, Opcode::F64X2Eq},
 1616|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1617|  8.39M|#line 470 "src/lexer-keywords.txt"
 1618|  8.39M|      {"i64x2.eq", TokenType::Binary, Opcode::I64X2Eq},
 1619|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1620|  8.39M|#line 483 "src/lexer-keywords.txt"
 1621|  8.39M|      {"i64x2.extend_high_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendHighI32X4U},
 1622|  8.39M|      {""},
 1623|  8.39M|#line 481 "src/lexer-keywords.txt"
 1624|  8.39M|      {"i64x2.extend_high_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendHighI32X4S},
 1625|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1626|  8.39M|#line 20 "src/lexer-keywords.txt"
 1627|  8.39M|      {"array", Type::Array, TokenType::Array},
 1628|  8.39M|      {""}, {""},
 1629|  8.39M|#line 27 "src/lexer-keywords.txt"
 1630|  8.39M|      {"assert_trap", TokenType::AssertTrap},
 1631|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1632|  8.39M|#line 596 "src/lexer-keywords.txt"
 1633|  8.39M|      {"v128.bitselect", TokenType::Ternary, Opcode::V128BitSelect},
 1634|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1635|  8.39M|#line 150 "src/lexer-keywords.txt"
 1636|  8.39M|      {"f64.sub", TokenType::Binary, Opcode::F64Sub},
 1637|  8.39M|#line 88 "src/lexer-keywords.txt"
 1638|  8.39M|      {"f32.sub", TokenType::Binary, Opcode::F32Sub},
 1639|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1640|  8.39M|#line 455 "src/lexer-keywords.txt"
 1641|  8.39M|      {"i64.sub", TokenType::Binary, Opcode::I64Sub},
 1642|  8.39M|#line 311 "src/lexer-keywords.txt"
 1643|  8.39M|      {"i32.sub", TokenType::Binary, Opcode::I32Sub},
 1644|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1645|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1646|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1647|  8.39M|#line 146 "src/lexer-keywords.txt"
 1648|  8.39M|      {"f64.promote_f32", TokenType::Convert, Opcode::F64PromoteF32},
 1649|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1650|  8.39M|#line 494 "src/lexer-keywords.txt"
 1651|  8.39M|      {"i64x2.extmul_high_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4U},
 1652|  8.39M|      {""},
 1653|  8.39M|#line 492 "src/lexer-keywords.txt"
 1654|  8.39M|      {"i64x2.extmul_high_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4S},
 1655|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1656|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1657|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1658|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1659|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1660|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1661|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1662|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1663|  8.39M|      {""}, {""}, {""},
 1664|  8.39M|#line 22 "src/lexer-keywords.txt"
 1665|  8.39M|      {"assert_exception", TokenType::AssertException},
 1666|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1667|  8.39M|#line 199 "src/lexer-keywords.txt"
 1668|  8.39M|      {"i16x8.bitmask", TokenType::Unary, Opcode::I16X8Bitmask},
 1669|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1670|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1671|  8.39M|      {""}, {""},
 1672|  8.39M|#line 23 "src/lexer-keywords.txt"
 1673|  8.39M|      {"assert_exhaustion", TokenType::AssertExhaustion},
 1674|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1675|  8.39M|#line 503 "src/lexer-keywords.txt"
 1676|  8.39M|      {"i8x16.bitmask", TokenType::Unary, Opcode::I8X16Bitmask},
 1677|  8.39M|      {""},
 1678|  8.39M|#line 201 "src/lexer-keywords.txt"
 1679|  8.39M|      {"i16x8.eq", TokenType::Compare, Opcode::I16X8Eq},
 1680|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1681|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1682|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1683|  8.39M|      {""},
 1684|  8.39M|#line 504 "src/lexer-keywords.txt"
 1685|  8.39M|      {"i8x16.eq", TokenType::Compare, Opcode::I8X16Eq},
 1686|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1687|  8.39M|#line 547 "src/lexer-keywords.txt"
 1688|  8.39M|      {"memory.atomic.wait64", TokenType::AtomicWait, Opcode::MemoryAtomicWait64},
 1689|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1690|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1691|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1692|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1693|  8.39M|      {""}, {""}, {""},
 1694|  8.39M|#line 85 "src/lexer-keywords.txt"
 1695|  8.39M|      {"f32.reinterpret_i32", TokenType::Convert, Opcode::F32ReinterpretI32},
 1696|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1697|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1698|  8.39M|#line 24 "src/lexer-keywords.txt"
 1699|  8.39M|      {"assert_invalid", TokenType::AssertInvalid},
 1700|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1701|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1702|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1703|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1704|  8.39M|#line 405 "src/lexer-keywords.txt"
 1705|  8.39M|      {"i64.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I64AtomicRmwSub},
 1706|  8.39M|#line 268 "src/lexer-keywords.txt"
 1707|  8.39M|      {"i32.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I32AtomicRmwSub},
 1708|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1709|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""},
 1710|  8.39M|#line 545 "src/lexer-keywords.txt"
 1711|  8.39M|      {"memory.atomic.notify", TokenType::AtomicNotify, Opcode::MemoryAtomicNotify},
 1712|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1713|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1714|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1715|  8.39M|#line 242 "src/lexer-keywords.txt"
 1716|  8.39M|      {"i16x8.extend_high_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendHighI8X16U},
 1717|  8.39M|      {""},
 1718|  8.39M|#line 241 "src/lexer-keywords.txt"
 1719|  8.39M|      {"i16x8.extend_high_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendHighI8X16S},
 1720|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1721|  8.39M|      {""},
 1722|  8.39M|#line 28 "src/lexer-keywords.txt"
 1723|  8.39M|      {"assert_unlinkable", TokenType::AssertUnlinkable},
 1724|  8.39M|      {""}, {""},
 1725|  8.39M|#line 300 "src/lexer-keywords.txt"
 1726|  8.39M|      {"i32.reinterpret_f32", TokenType::Convert, Opcode::I32ReinterpretF32},
 1727|  8.39M|      {""}, {""}, {""}, {""},
 1728|  8.39M|#line 182 "src/lexer-keywords.txt"
 1729|  8.39M|      {"f64x2.convert_low_i32x4_u", TokenType::Unary, Opcode::F64X2ConvertLowI32X4U},
 1730|  8.39M|      {""},
 1731|  8.39M|#line 181 "src/lexer-keywords.txt"
 1732|  8.39M|      {"f64x2.convert_low_i32x4_s", TokenType::Unary, Opcode::F64X2ConvertLowI32X4S},
 1733|  8.39M|      {""},
 1734|  8.39M|#line 235 "src/lexer-keywords.txt"
 1735|  8.39M|      {"i16x8.extadd_pairwise_i8x16_u", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16U},
 1736|  8.39M|      {""},
 1737|  8.39M|#line 234 "src/lexer-keywords.txt"
 1738|  8.39M|      {"i16x8.extadd_pairwise_i8x16_s", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16S},
 1739|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1740|  8.39M|      {""},
 1741|  8.39M|#line 546 "src/lexer-keywords.txt"
 1742|  8.39M|      {"memory.atomic.wait32", TokenType::AtomicWait, Opcode::MemoryAtomicWait32},
 1743|  8.39M|      {""}, {""}, {""}, {""}, {""},
 1744|  8.39M|#line 520 "src/lexer-keywords.txt"
 1745|  8.39M|      {"i8x16.narrow_i16x8_u", TokenType::Binary, Opcode::I8X16NarrowI16X8U},
 1746|  8.39M|      {""},
 1747|  8.39M|#line 519 "src/lexer-keywords.txt"
 1748|  8.39M|      {"i8x16.narrow_i16x8_s", TokenType::Binary, Opcode::I8X16NarrowI16X8S},
 1749|  8.39M|      {""},
 1750|  8.39M|#line 222 "src/lexer-keywords.txt"
 1751|  8.39M|      {"i16x8.q15mulr_sat_s", TokenType::Binary, Opcode::I16X8Q15mulrSatS},
 1752|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1753|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1754|  8.39M|#line 29 "src/lexer-keywords.txt"
 1755|  8.39M|      {"atomic.fence", TokenType::AtomicFence, Opcode::AtomicFence},
 1756|  8.39M|      {""}, {""}, {""}, {""},
 1757|  8.39M|#line 239 "src/lexer-keywords.txt"
 1758|  8.39M|      {"i16x8.extmul_high_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16U},
 1759|  8.39M|      {""},
 1760|  8.39M|#line 237 "src/lexer-keywords.txt"
 1761|  8.39M|      {"i16x8.extmul_high_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16S},
 1762|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1763|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1764|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1765|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1766|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1767|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1768|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1769|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1770|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1771|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1772|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1773|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1774|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1775|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1776|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1777|  8.39M|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
 1778|  8.39M|#line 183 "src/lexer-keywords.txt"
 1779|  8.39M|      {"f64x2.promote_low_f32x4", TokenType::Unary, Opcode::F64X2PromoteLowF32X4}
 1780|  8.39M|    };
 1781|       |
 1782|  8.39M|  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
  ------------------
  |  Branch (1782:7): [True: 8.32M, False: 61.8k]
  |  Branch (1782:33): [True: 7.77M, False: 554k]
  ------------------
 1783|  7.77M|    {
 1784|  7.77M|      unsigned int key = hash (str, len);
 1785|       |
 1786|  7.77M|      if (key <= MAX_HASH_VALUE)
  ------------------
  |  Branch (1786:11): [True: 7.58M, False: 190k]
  ------------------
 1787|  7.58M|        {
 1788|  7.58M|          const char *s = wordlist[key].name;
 1789|       |
 1790|  7.58M|          if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
  ------------------
  |  Branch (1790:15): [True: 6.91M, False: 671k]
  |  Branch (1790:29): [True: 6.82M, False: 87.1k]
  |  Branch (1790:67): [True: 6.82M, False: 512]
  ------------------
 1791|  6.82M|            return &wordlist[key];
 1792|  7.58M|        }
 1793|  7.77M|    }
 1794|  1.56M|  return 0;
 1795|  8.39M|}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_19TokenInfoC2EPKc:
   34|  1.62k|  TokenInfo(const char* name) : name(name) {}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_19TokenInfoC2EPKcNS_9TokenTypeENS_6OpcodeE:
   42|    533|      : name(name), token_type(token_type), opcode(opcode) {}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_19TokenInfoC2EPKcNS_4TypeE:
   38|      8|      : name(name), token_type(TokenType::ValueType), value_type(value_type) {}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_19TokenInfoC2EPKcNS_9TokenTypeE:
   36|     55|      : name(name), token_type(token_type) {}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_19TokenInfoC2EPKcNS_4TypeENS_9TokenTypeE:
   40|      5|      : name(name), token_type(token_type), value_type(value_type) {}
wast-lexer.cc:_ZN4wabt12_GLOBAL__N_112Perfect_Hash4hashEPKcm:
   63|  7.77M|{
   64|  7.77M|  static unsigned short asso_values[] =
   65|  7.77M|    {
   66|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   67|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   68|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   69|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   70|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230,   13, 2230, 2230,  426,
   71|  7.77M|       351,   14,   17,   13,  176,  531,   32, 2230, 2230, 2230,
   72|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   73|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   74|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   75|  7.77M|      2230, 2230, 2230, 2230, 2230,  183,   13,   16,  811,   21,
   76|  7.77M|        68,   16,  326,   13,  347,  223,   20,   13,   15,  140,
   77|  7.77M|        80,   54,  559,  611,   14,   15,   24,   13,  556,  521,
   78|  7.77M|       125,  416,  213, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   79|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   80|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   81|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   82|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   83|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   84|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   85|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   86|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   87|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   88|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   89|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   90|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
   91|  7.77M|      2230, 2230, 2230, 2230, 2230, 2230, 2230
   92|  7.77M|    };
   93|  7.77M|  unsigned int hval = len;
   94|       |
   95|  7.77M|  switch (hval)
   96|  7.77M|    {
   97|  14.4k|      default:
  ------------------
  |  Branch (97:7): [True: 14.4k, False: 7.75M]
  ------------------
   98|  14.4k|        hval += asso_values[static_cast<unsigned char>(str[26])];
   99|       |      /*FALLTHROUGH*/
  100|  28.1k|      case 26:
  ------------------
  |  Branch (100:7): [True: 13.6k, False: 7.76M]
  ------------------
  101|  30.3k|      case 25:
  ------------------
  |  Branch (101:7): [True: 2.20k, False: 7.77M]
  ------------------
  102|  34.7k|      case 24:
  ------------------
  |  Branch (102:7): [True: 4.36k, False: 7.76M]
  ------------------
  103|  42.0k|      case 23:
  ------------------
  |  Branch (103:7): [True: 7.33k, False: 7.76M]
  ------------------
  104|  42.0k|        hval += asso_values[static_cast<unsigned char>(str[22])];
  105|       |      /*FALLTHROUGH*/
  106|  61.7k|      case 22:
  ------------------
  |  Branch (106:7): [True: 19.7k, False: 7.75M]
  ------------------
  107|  70.1k|      case 21:
  ------------------
  |  Branch (107:7): [True: 8.35k, False: 7.76M]
  ------------------
  108|  86.3k|      case 20:
  ------------------
  |  Branch (108:7): [True: 16.1k, False: 7.75M]
  ------------------
  109|   103k|      case 19:
  ------------------
  |  Branch (109:7): [True: 17.1k, False: 7.75M]
  ------------------
  110|   103k|        hval += asso_values[static_cast<unsigned char>(str[18])];
  111|       |      /*FALLTHROUGH*/
  112|   132k|      case 18:
  ------------------
  |  Branch (112:7): [True: 29.5k, False: 7.74M]
  ------------------
  113|   132k|        hval += asso_values[static_cast<unsigned char>(str[17])];
  114|       |      /*FALLTHROUGH*/
  115|   142k|      case 17:
  ------------------
  |  Branch (115:7): [True: 9.85k, False: 7.76M]
  ------------------
  116|   142k|        hval += asso_values[static_cast<unsigned char>(str[16])];
  117|       |      /*FALLTHROUGH*/
  118|   166k|      case 16:
  ------------------
  |  Branch (118:7): [True: 23.8k, False: 7.75M]
  ------------------
  119|   182k|      case 15:
  ------------------
  |  Branch (119:7): [True: 16.3k, False: 7.75M]
  ------------------
  120|   182k|        hval += asso_values[static_cast<unsigned char>(str[14])];
  121|       |      /*FALLTHROUGH*/
  122|   206k|      case 14:
  ------------------
  |  Branch (122:7): [True: 23.1k, False: 7.75M]
  ------------------
  123|   249k|      case 13:
  ------------------
  |  Branch (123:7): [True: 42.9k, False: 7.73M]
  ------------------
  124|   291k|      case 12:
  ------------------
  |  Branch (124:7): [True: 42.7k, False: 7.73M]
  ------------------
  125|   291k|        hval += asso_values[static_cast<unsigned char>(str[11])];
  126|       |      /*FALLTHROUGH*/
  127|   340k|      case 11:
  ------------------
  |  Branch (127:7): [True: 48.5k, False: 7.72M]
  ------------------
  128|   461k|      case 10:
  ------------------
  |  Branch (128:7): [True: 121k, False: 7.65M]
  ------------------
  129|   461k|        hval += asso_values[static_cast<unsigned char>(str[9])];
  130|       |      /*FALLTHROUGH*/
  131|   891k|      case 9:
  ------------------
  |  Branch (131:7): [True: 429k, False: 7.34M]
  ------------------
  132|   931k|      case 8:
  ------------------
  |  Branch (132:7): [True: 40.4k, False: 7.73M]
  ------------------
  133|   931k|        hval += asso_values[static_cast<unsigned char>(str[7])];
  134|       |      /*FALLTHROUGH*/
  135|   983k|      case 7:
  ------------------
  |  Branch (135:7): [True: 52.4k, False: 7.72M]
  ------------------
  136|   983k|        hval += asso_values[static_cast<unsigned char>(str[6])];
  137|       |      /*FALLTHROUGH*/
  138|  2.69M|      case 6:
  ------------------
  |  Branch (138:7): [True: 1.70M, False: 6.06M]
  ------------------
  139|  2.69M|        hval += asso_values[static_cast<unsigned char>(str[5])];
  140|       |      /*FALLTHROUGH*/
  141|  3.16M|      case 5:
  ------------------
  |  Branch (141:7): [True: 468k, False: 7.30M]
  ------------------
  142|  3.16M|        hval += asso_values[static_cast<unsigned char>(str[4])];
  143|       |      /*FALLTHROUGH*/
  144|  6.20M|      case 4:
  ------------------
  |  Branch (144:7): [True: 3.04M, False: 4.72M]
  ------------------
  145|  7.45M|      case 3:
  ------------------
  |  Branch (145:7): [True: 1.24M, False: 6.52M]
  ------------------
  146|  7.45M|        hval += asso_values[static_cast<unsigned char>(str[2]+1)];
  147|       |      /*FALLTHROUGH*/
  148|  7.77M|      case 2:
  ------------------
  |  Branch (148:7): [True: 315k, False: 7.45M]
  ------------------
  149|  7.77M|      case 1:
  ------------------
  |  Branch (149:7): [True: 0, False: 7.77M]
  ------------------
  150|  7.77M|        hval += asso_values[static_cast<unsigned char>(str[0]+1)];
  151|  7.77M|        break;
  152|  7.77M|    }
  153|  7.77M|  return hval + asso_values[static_cast<unsigned char>(str[len - 1])];
  154|  7.77M|}

_ZN4wabt18ResolveNamesModuleEPNS_6ModuleEPNSt3__16vectorINS_5ErrorENS2_9allocatorIS4_EEEE:
  658|  6.64k|Result ResolveNamesModule(Module* module, Errors* errors) {
  659|  6.64k|  NameResolver resolver(nullptr, errors);
  660|  6.64k|  return resolver.VisitModule(module);
  661|  6.64k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolverC2EPNS_6ScriptEPNSt3__16vectorINS_5ErrorENS4_9allocatorIS6_EEEE:
  124|  6.64k|    : errors_(errors), script_(script), visitor_(this) {}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14BeginBlockExprEPNS_13BlockExprBaseILNS_8ExprTypeE8EEE:
  246|  3.81k|Result NameResolver::BeginBlockExpr(BlockExpr* expr) {
  247|  3.81k|  PushLabel(expr->block.label);
  248|  3.81k|  ResolveBlockDeclarationVar(&expr->block.decl);
  249|  3.81k|  return Result::Ok;
  250|  3.81k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver9PushLabelERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  136|  77.3k|void NameResolver::PushLabel(const std::string& label) {
  137|  77.3k|  labels_.push_back(label);
  138|  77.3k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver26ResolveBlockDeclarationVarEPNS_15FuncDeclarationE:
  240|  77.3k|void NameResolver::ResolveBlockDeclarationVar(BlockDeclaration* decl) {
  241|  77.3k|  if (decl->has_func_type) {
  ------------------
  |  Branch (241:7): [True: 2.34k, False: 75.0k]
  ------------------
  242|  2.34k|    ResolveFuncTypeVar(&decl->type_var);
  243|  2.34k|  }
  244|  77.3k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver18ResolveFuncTypeVarEPNS_3VarE:
  199|  8.53k|void NameResolver::ResolveFuncTypeVar(Var* var) {
  200|  8.53k|  ResolveVar(&current_module_->type_bindings, var, "type");
  201|  8.53k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10ResolveVarEPKNS_11BindingHashEPNS_3VarEPKc:
  178|   461k|                              const char* desc) {
  179|   461k|  if (var->is_name()) {
  ------------------
  |  Branch (179:7): [True: 179k, False: 281k]
  ------------------
  180|   179k|    Index index = bindings->FindIndex(*var);
  181|   179k|    if (index == kInvalidIndex) {
  ------------------
  |  Branch (181:9): [True: 168k, False: 11.3k]
  ------------------
  182|   168k|      PrintError(&var->loc, "undefined %s variable \"%s\"", desc,
  183|   168k|                 var->name().c_str());
  184|   168k|      return;
  185|   168k|    }
  186|       |
  187|  11.3k|    var->set_index(index);
  188|  11.3k|  }
  189|   461k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10PrintErrorEPKNS_8LocationEPKcz:
  130|  1.40M|                                                       ...) {
  131|  1.40M|  result_ = Result::Error;
  132|  1.40M|  WABT_SNPRINTF_ALLOCA(buffer, length, format);
  ------------------
  |  |   36|  1.40M|  va_list args;                                                            \
  |  |   37|  1.40M|  va_list args_copy;                                                       \
  |  |   38|  1.40M|  va_start(args, format);                                                  \
  |  |   39|  1.40M|  va_copy(args_copy, args);                                                \
  |  |   40|  1.40M|  char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE];                    \
  |  |   41|  1.40M|  char* buffer = fixed_buf;                                                \
  |  |   42|  1.40M|  size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \
  |  |  ------------------
  |  |  |  |  288|  1.40M|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   43|  1.40M|  va_end(args);                                                            \
  |  |   44|  1.40M|  if (len + 1 > sizeof(fixed_buf)) {                                       \
  |  |  ------------------
  |  |  |  Branch (44:7): [True: 1.27k, False: 1.40M]
  |  |  ------------------
  |  |   45|  1.27k|    buffer = static_cast<char*>(alloca(len + 1));                          \
  |  |   46|  1.27k|    len = wabt_vsnprintf(buffer, len + 1, format, args_copy);              \
  |  |  ------------------
  |  |  |  |  288|  1.27k|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   47|  1.27k|  }                                                                        \
  |  |   48|  1.40M|  va_end(args_copy)
  ------------------
  133|  1.40M|  errors_->emplace_back(ErrorLevel::Error, *loc, buffer);
  134|  1.40M|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver12EndBlockExprEPNS_13BlockExprBaseILNS_8ExprTypeE8EEE:
  252|  3.81k|Result NameResolver::EndBlockExpr(BlockExpr* expr) {
  253|  3.81k|  PopLabel();
  254|  3.81k|  return Result::Ok;
  255|  3.81k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver8PopLabelEv:
  140|  77.3k|void NameResolver::PopLabel() {
  141|  77.3k|  labels_.pop_back();
  142|  77.3k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver8OnBrExprEPNS_7VarExprILNS_8ExprTypeE9EEE:
  268|  3.49k|Result NameResolver::OnBrExpr(BrExpr* expr) {
  269|  3.49k|  ResolveLabelVar(&expr->var);
  270|  3.49k|  return Result::Ok;
  271|  3.49k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15ResolveLabelVarEPNS_3VarE:
  162|   631k|void NameResolver::ResolveLabelVar(Var* var) {
  163|   631k|  if (var->is_name()) {
  ------------------
  |  Branch (163:7): [True: 627k, False: 4.27k]
  ------------------
  164|   632k|    for (int i = labels_.size() - 1; i >= 0; --i) {
  ------------------
  |  Branch (164:38): [True: 5.95k, False: 626k]
  ------------------
  165|  5.95k|      const std::string& label = labels_[i];
  166|  5.95k|      if (label == var->name()) {
  ------------------
  |  Branch (166:11): [True: 1.35k, False: 4.60k]
  ------------------
  167|  1.35k|        var->set_index(labels_.size() - i - 1);
  168|  1.35k|        return;
  169|  1.35k|      }
  170|  5.95k|    }
  171|   626k|    PrintError(&var->loc, "undefined label variable \"%s\"",
  172|   626k|               var->name().c_str());
  173|   626k|  }
  174|   631k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10OnBrIfExprEPNS_7VarExprILNS_8ExprTypeE10EEE:
  273|    280|Result NameResolver::OnBrIfExpr(BrIfExpr* expr) {
  274|    280|  ResolveLabelVar(&expr->var);
  275|    280|  return Result::Ok;
  276|    280|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver13OnBrTableExprEPNS_11BrTableExprE:
  278|    579|Result NameResolver::OnBrTableExpr(BrTableExpr* expr) {
  279|    579|  for (Var& target : expr->targets)
  ------------------
  |  Branch (279:20): [True: 625k, False: 579]
  ------------------
  280|   625k|    ResolveLabelVar(&target);
  281|    579|  ResolveLabelVar(&expr->default_target);
  282|    579|  return Result::Ok;
  283|    579|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver17BeginTryTableExprEPNS_12TryTableExprE:
  447|  1.60k|Result NameResolver::BeginTryTableExpr(TryTableExpr* expr) {
  448|  1.60k|  for (TableCatch& catch_ : expr->catches) {
  ------------------
  |  Branch (448:27): [True: 1.53k, False: 1.60k]
  ------------------
  449|  1.53k|    if (!catch_.IsCatchAll()) {
  ------------------
  |  Branch (449:9): [True: 1.33k, False: 196]
  ------------------
  450|  1.33k|      ResolveTagVar(&catch_.tag);
  451|  1.33k|    }
  452|  1.53k|    ResolveLabelVar(&catch_.target);
  453|  1.53k|  }
  454|  1.60k|  PushLabel(expr->block.label);
  455|  1.60k|  ResolveBlockDeclarationVar(&expr->block.decl);
  456|  1.60k|  return Result::Ok;
  457|  1.60k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver13ResolveTagVarEPNS_3VarE:
  211|  6.11k|void NameResolver::ResolveTagVar(Var* var) {
  212|  6.11k|  ResolveVar(&current_module_->tag_bindings, var, "tag");
  213|  6.11k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15EndTryTableExprEPNS_12TryTableExprE:
  459|  1.60k|Result NameResolver::EndTryTableExpr(TryTableExpr*) {
  460|  1.60k|  PopLabel();
  461|  1.60k|  return Result::Ok;
  462|  1.60k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10OnCallExprEPNS_7VarExprILNS_8ExprTypeE12EEE:
  285|  2.21k|Result NameResolver::OnCallExpr(CallExpr* expr) {
  286|  2.21k|  ResolveFuncVar(&expr->var);
  287|  2.21k|  return Result::Ok;
  288|  2.21k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14ResolveFuncVarEPNS_3VarE:
  191|   143k|void NameResolver::ResolveFuncVar(Var* var) {
  192|   143k|  ResolveVar(&current_module_->func_bindings, var, "function");
  193|   143k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver18OnCallIndirectExprEPNS_16CallIndirectExprE:
  290|  2.14k|Result NameResolver::OnCallIndirectExpr(CallIndirectExpr* expr) {
  291|  2.14k|  if (expr->decl.has_func_type) {
  ------------------
  |  Branch (291:7): [True: 1.19k, False: 955]
  ------------------
  292|  1.19k|    ResolveFuncTypeVar(&expr->decl.type_var);
  293|  1.19k|  }
  294|  2.14k|  ResolveTableVar(&expr->table);
  295|  2.14k|  return Result::Ok;
  296|  2.14k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15ResolveTableVarEPNS_3VarE:
  203|   228k|void NameResolver::ResolveTableVar(Var* var) {
  204|   228k|  ResolveVar(&current_module_->table_bindings, var, "table");
  205|   228k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnGlobalGetExprEPNS_7VarExprILNS_8ExprTypeE20EEE:
  311|    891|Result NameResolver::OnGlobalGetExpr(GlobalGetExpr* expr) {
  312|    891|  ResolveGlobalVar(&expr->var);
  313|    891|  return Result::Ok;
  314|    891|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16ResolveGlobalVarEPNS_3VarE:
  195|  2.92k|void NameResolver::ResolveGlobalVar(Var* var) {
  196|  2.92k|  ResolveVar(&current_module_->global_bindings, var, "global");
  197|  2.92k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnGlobalSetExprEPNS_7VarExprILNS_8ExprTypeE21EEE:
  316|    850|Result NameResolver::OnGlobalSetExpr(GlobalSetExpr* expr) {
  317|    850|  ResolveGlobalVar(&expr->var);
  318|    850|  return Result::Ok;
  319|    850|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11BeginIfExprEPNS_6IfExprE:
  321|  1.83k|Result NameResolver::BeginIfExpr(IfExpr* expr) {
  322|  1.83k|  PushLabel(expr->true_.label);
  323|  1.83k|  ResolveBlockDeclarationVar(&expr->true_.decl);
  324|  1.83k|  return Result::Ok;
  325|  1.83k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver9EndIfExprEPNS_6IfExprE:
  327|  1.83k|Result NameResolver::EndIfExpr(IfExpr* expr) {
  328|  1.83k|  PopLabel();
  329|  1.83k|  return Result::Ok;
  330|  1.83k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10OnLoadExprEPNS_13LoadStoreExprILNS_8ExprTypeE23EEE:
  332|    612|Result NameResolver::OnLoadExpr(LoadExpr* expr) {
  333|    612|  ResolveMemoryVar(&expr->memidx);
  334|    612|  return Result::Ok;
  335|    612|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16ResolveMemoryVarEPNS_3VarE:
  207|  64.8k|void NameResolver::ResolveMemoryVar(Var* var) {
  208|  64.8k|  ResolveVar(&current_module_->memory_bindings, var, "memory");
  209|  64.8k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnLocalGetExprEPNS_7VarExprILNS_8ExprTypeE24EEE:
  337|  1.03k|Result NameResolver::OnLocalGetExpr(LocalGetExpr* expr) {
  338|  1.03k|  ResolveLocalVar(&expr->var);
  339|  1.03k|  return Result::Ok;
  340|  1.03k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15ResolveLocalVarEPNS_3VarE:
  223|  3.14k|void NameResolver::ResolveLocalVar(Var* var) {
  224|  3.14k|  if (var->is_name()) {
  ------------------
  |  Branch (224:7): [True: 2.36k, False: 784]
  ------------------
  225|  2.36k|    if (!current_func_) {
  ------------------
  |  Branch (225:9): [True: 582, False: 1.78k]
  ------------------
  226|    582|      return;
  227|    582|    }
  228|       |
  229|  1.78k|    Index index = current_func_->GetLocalIndex(*var);
  230|  1.78k|    if (index == kInvalidIndex) {
  ------------------
  |  Branch (230:9): [True: 1.19k, False: 585]
  ------------------
  231|  1.19k|      PrintError(&var->loc, "undefined local variable \"%s\"",
  232|  1.19k|                 var->name().c_str());
  233|  1.19k|      return;
  234|  1.19k|    }
  235|       |
  236|    585|    var->set_index(index);
  237|    585|  }
  238|  3.14k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnLocalSetExprEPNS_7VarExprILNS_8ExprTypeE25EEE:
  342|  1.04k|Result NameResolver::OnLocalSetExpr(LocalSetExpr* expr) {
  343|  1.04k|  ResolveLocalVar(&expr->var);
  344|  1.04k|  return Result::Ok;
  345|  1.04k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnLocalTeeExprEPNS_7VarExprILNS_8ExprTypeE26EEE:
  347|  1.06k|Result NameResolver::OnLocalTeeExpr(LocalTeeExpr* expr) {
  348|  1.06k|  ResolveLocalVar(&expr->var);
  349|  1.06k|  return Result::Ok;
  350|  1.06k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver13BeginLoopExprEPNS_13BlockExprBaseILNS_8ExprTypeE27EEE:
  257|  41.4k|Result NameResolver::BeginLoopExpr(LoopExpr* expr) {
  258|  41.4k|  PushLabel(expr->block.label);
  259|  41.4k|  ResolveBlockDeclarationVar(&expr->block.decl);
  260|  41.4k|  return Result::Ok;
  261|  41.4k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11EndLoopExprEPNS_13BlockExprBaseILNS_8ExprTypeE27EEE:
  263|  41.4k|Result NameResolver::EndLoopExpr(LoopExpr* expr) {
  264|  41.4k|  PopLabel();
  265|  41.4k|  return Result::Ok;
  266|  41.4k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnMemoryCopyExprEPNS_16MemoryBinaryExprILNS_8ExprTypeE28EEE:
  352|    269|Result NameResolver::OnMemoryCopyExpr(MemoryCopyExpr* expr) {
  353|    269|  ResolveMemoryVar(&expr->destmemidx);
  354|    269|  ResolveMemoryVar(&expr->srcmemidx);
  355|    269|  return Result::Ok;
  356|    269|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnDataDropExprEPNS_7VarExprILNS_8ExprTypeE29EEE:
  358|    949|Result NameResolver::OnDataDropExpr(DataDropExpr* expr) {
  359|    949|  ResolveDataSegmentVar(&expr->var);
  360|    949|  return Result::Ok;
  361|    949|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver21ResolveDataSegmentVarEPNS_3VarE:
  215|  1.81k|void NameResolver::ResolveDataSegmentVar(Var* var) {
  216|  1.81k|  ResolveVar(&current_module_->data_segment_bindings, var, "data segment");
  217|  1.81k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnMemoryFillExprEPNS_10MemoryExprILNS_8ExprTypeE30EEE:
  363|    293|Result NameResolver::OnMemoryFillExpr(MemoryFillExpr* expr) {
  364|    293|  ResolveMemoryVar(&expr->memidx);
  365|    293|  return Result::Ok;
  366|    293|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnMemoryGrowExprEPNS_10MemoryExprILNS_8ExprTypeE31EEE:
  368|    262|Result NameResolver::OnMemoryGrowExpr(MemoryGrowExpr* expr) {
  369|    262|  ResolveMemoryVar(&expr->memidx);
  370|    262|  return Result::Ok;
  371|    262|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnMemoryInitExprEPNS_13MemoryVarExprILNS_8ExprTypeE32EEE:
  373|    865|Result NameResolver::OnMemoryInitExpr(MemoryInitExpr* expr) {
  374|    865|  ResolveDataSegmentVar(&expr->var);
  375|    865|  ResolveMemoryVar(&expr->memidx);
  376|    865|  return Result::Ok;
  377|    865|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnMemorySizeExprEPNS_10MemoryExprILNS_8ExprTypeE33EEE:
  379|  1.53k|Result NameResolver::OnMemorySizeExpr(MemorySizeExpr* expr) {
  380|  1.53k|  ResolveMemoryVar(&expr->memidx);
  381|  1.53k|  return Result::Ok;
  382|  1.53k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnTableCopyExprEPNS_13TableCopyExprE:
  389|  2.33k|Result NameResolver::OnTableCopyExpr(TableCopyExpr* expr) {
  390|  2.33k|  ResolveTableVar(&expr->dst_table);
  391|  2.33k|  ResolveTableVar(&expr->src_table);
  392|  2.33k|  return Result::Ok;
  393|  2.33k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnElemDropExprEPNS_7VarExprILNS_8ExprTypeE51EEE:
  384|  1.20k|Result NameResolver::OnElemDropExpr(ElemDropExpr* expr) {
  385|  1.20k|  ResolveElemSegmentVar(&expr->var);
  386|  1.20k|  return Result::Ok;
  387|  1.20k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver21ResolveElemSegmentVarEPNS_3VarE:
  219|  5.16k|void NameResolver::ResolveElemSegmentVar(Var* var) {
  220|  5.16k|  ResolveVar(&current_module_->elem_segment_bindings, var, "elem segment");
  221|  5.16k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnTableInitExprEPNS_13TableInitExprE:
  395|  3.95k|Result NameResolver::OnTableInitExpr(TableInitExpr* expr) {
  396|  3.95k|  ResolveElemSegmentVar(&expr->segment_index);
  397|  3.95k|  ResolveTableVar(&expr->table_index);
  398|  3.95k|  return Result::Ok;
  399|  3.95k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnTableGetExprEPNS_7VarExprILNS_8ExprTypeE53EEE:
  401|    885|Result NameResolver::OnTableGetExpr(TableGetExpr* expr) {
  402|    885|  ResolveTableVar(&expr->var);
  403|    885|  return Result::Ok;
  404|    885|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver14OnTableSetExprEPNS_7VarExprILNS_8ExprTypeE56EEE:
  406|  1.22k|Result NameResolver::OnTableSetExpr(TableSetExpr* expr) {
  407|  1.22k|  ResolveTableVar(&expr->var);
  408|  1.22k|  return Result::Ok;
  409|  1.22k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnTableGrowExprEPNS_7VarExprILNS_8ExprTypeE54EEE:
  411|    909|Result NameResolver::OnTableGrowExpr(TableGrowExpr* expr) {
  412|    909|  ResolveTableVar(&expr->var);
  413|    909|  return Result::Ok;
  414|    909|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnTableSizeExprEPNS_7VarExprILNS_8ExprTypeE55EEE:
  416|  1.22k|Result NameResolver::OnTableSizeExpr(TableSizeExpr* expr) {
  417|  1.22k|  ResolveTableVar(&expr->var);
  418|  1.22k|  return Result::Ok;
  419|  1.22k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver15OnTableFillExprEPNS_7VarExprILNS_8ExprTypeE57EEE:
  421|  1.10k|Result NameResolver::OnTableFillExpr(TableFillExpr* expr) {
  422|  1.10k|  ResolveTableVar(&expr->var);
  423|  1.10k|  return Result::Ok;
  424|  1.10k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver13OnRefFuncExprEPNS_7VarExprILNS_8ExprTypeE36EEE:
  426|    885|Result NameResolver::OnRefFuncExpr(RefFuncExpr* expr) {
  427|    885|  ResolveFuncVar(&expr->var);
  428|    885|  return Result::Ok;
  429|    885|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16OnReturnCallExprEPNS_7VarExprILNS_8ExprTypeE40EEE:
  298|    856|Result NameResolver::OnReturnCallExpr(ReturnCallExpr* expr) {
  299|    856|  ResolveFuncVar(&expr->var);
  300|    856|  return Result::Ok;
  301|    856|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver24OnReturnCallIndirectExprEPNS_22ReturnCallIndirectExprE:
  303|  2.15k|Result NameResolver::OnReturnCallIndirectExpr(ReturnCallIndirectExpr* expr) {
  304|  2.15k|  if (expr->decl.has_func_type) {
  ------------------
  |  Branch (304:7): [True: 1.23k, False: 919]
  ------------------
  305|  1.23k|    ResolveFuncTypeVar(&expr->decl.type_var);
  306|  1.23k|  }
  307|  2.15k|  ResolveTableVar(&expr->table);
  308|  2.15k|  return Result::Ok;
  309|  2.15k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11OnStoreExprEPNS_13LoadStoreExprILNS_8ExprTypeE49EEE:
  431|    344|Result NameResolver::OnStoreExpr(StoreExpr* expr) {
  432|    344|  ResolveMemoryVar(&expr->memidx);
  433|    344|  return Result::Ok;
  434|    344|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver12BeginTryExprEPNS_7TryExprE:
  436|  28.6k|Result NameResolver::BeginTryExpr(TryExpr* expr) {
  437|  28.6k|  PushLabel(expr->block.label);
  438|  28.6k|  ResolveBlockDeclarationVar(&expr->block.decl);
  439|  28.6k|  return Result::Ok;
  440|  28.6k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11OnCatchExprEPNS_7TryExprEPNS_5CatchE:
  464|  10.9k|Result NameResolver::OnCatchExpr(TryExpr*, Catch* catch_) {
  465|  10.9k|  if (!catch_->IsCatchAll()) {
  ------------------
  |  Branch (465:7): [True: 2.24k, False: 8.75k]
  ------------------
  466|  2.24k|    ResolveTagVar(&catch_->var);
  467|  2.24k|  }
  468|  10.9k|  return Result::Ok;
  469|  10.9k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver10EndTryExprEPNS_7TryExprE:
  442|  28.6k|Result NameResolver::EndTryExpr(TryExpr*) {
  443|  28.6k|  PopLabel();
  444|  28.6k|  return Result::Ok;
  445|  28.6k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11OnThrowExprEPNS_7VarExprILNS_8ExprTypeE59EEE:
  482|  1.80k|Result NameResolver::OnThrowExpr(ThrowExpr* expr) {
  483|  1.80k|  ResolveTagVar(&expr->var);
  484|  1.80k|  return Result::Ok;
  485|  1.80k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver13OnRethrowExprEPNS_7VarExprILNS_8ExprTypeE38EEE:
  487|    261|Result NameResolver::OnRethrowExpr(RethrowExpr* expr) {
  488|       |  // Note: the variable refers to corresponding (enclosing) catch, using the try
  489|       |  // block label for context.
  490|    261|  ResolveLabelVar(&expr->var);
  491|    261|  return Result::Ok;
  492|    261|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver18OnSimdLoadLaneExprEPNS_16SimdLoadLaneExprE:
  494|    262|Result NameResolver::OnSimdLoadLaneExpr(SimdLoadLaneExpr* expr) {
  495|    262|  ResolveMemoryVar(&expr->memidx);
  496|    262|  return Result::Ok;
  497|    262|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver19OnSimdStoreLaneExprEPNS_17SimdStoreLaneExprE:
  499|    378|Result NameResolver::OnSimdStoreLaneExpr(SimdStoreLaneExpr* expr) {
  500|    378|  ResolveMemoryVar(&expr->memidx);
  501|    378|  return Result::Ok;
  502|    378|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11VisitModuleEPNS_6ModuleE:
  571|  6.64k|Result NameResolver::VisitModule(Module* module) {
  572|  6.64k|  current_module_ = module;
  573|  6.64k|  CheckDuplicateBindings(&module->elem_segment_bindings, "elem");
  574|  6.64k|  CheckDuplicateBindings(&module->func_bindings, "function");
  575|  6.64k|  CheckDuplicateBindings(&module->global_bindings, "global");
  576|  6.64k|  CheckDuplicateBindings(&module->type_bindings, "type");
  577|  6.64k|  CheckDuplicateBindings(&module->table_bindings, "table");
  578|  6.64k|  CheckDuplicateBindings(&module->memory_bindings, "memory");
  579|  6.64k|  CheckDuplicateBindings(&module->tag_bindings, "tag");
  580|       |
  581|  6.64k|  for (Func* func : module->funcs)
  ------------------
  |  Branch (581:19): [True: 870k, False: 6.64k]
  ------------------
  582|   870k|    VisitFunc(func);
  583|  6.64k|  for (Export* export_ : module->exports)
  ------------------
  |  Branch (583:24): [True: 9.22k, False: 6.64k]
  ------------------
  584|  9.22k|    VisitExport(export_);
  585|  6.64k|  for (Global* global : module->globals)
  ------------------
  |  Branch (585:23): [True: 120k, False: 6.64k]
  ------------------
  586|   120k|    VisitGlobal(global);
  587|  6.64k|  for (Tag* tag : module->tags)
  ------------------
  |  Branch (587:17): [True: 61.8k, False: 6.64k]
  ------------------
  588|  61.8k|    VisitTag(tag);
  589|  6.64k|  for (ElemSegment* elem_segment : module->elem_segments)
  ------------------
  |  Branch (589:34): [True: 209k, False: 6.64k]
  ------------------
  590|   209k|    VisitElemSegment(elem_segment);
  591|  6.64k|  for (DataSegment* data_segment : module->data_segments)
  ------------------
  |  Branch (591:34): [True: 58.9k, False: 6.64k]
  ------------------
  592|  58.9k|    VisitDataSegment(data_segment);
  593|  6.64k|  for (Var* start : module->starts)
  ------------------
  |  Branch (593:19): [True: 67, False: 6.64k]
  ------------------
  594|     67|    ResolveFuncVar(start);
  595|  6.64k|  current_module_ = nullptr;
  596|  6.64k|  return result_;
  597|  6.64k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver22CheckDuplicateBindingsEPKNS_11BindingHashEPKc:
  145|  46.4k|                                          const char* desc) {
  146|  46.4k|  bindings->FindDuplicates([this, desc](const BindingHash::value_type& a,
  147|  46.4k|                                        const BindingHash::value_type& b) {
  148|  46.4k|    PrintDuplicateBindingsError(a, b, desc);
  149|  46.4k|  });
  150|  46.4k|}
resolve-names.cc:_ZZN4wabt12_GLOBAL__N_112NameResolver22CheckDuplicateBindingsEPKNS_11BindingHashEPKcENK3$_0clERKNSt3__14pairIKNS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEENS_7BindingEEESK_:
  147|   594k|                                        const BindingHash::value_type& b) {
  148|   594k|    PrintDuplicateBindingsError(a, b, desc);
  149|   594k|  });
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver27PrintDuplicateBindingsErrorERKNSt3__14pairIKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_7BindingEEESE_PKc:
  154|   606k|                                               const char* desc) {
  155|       |  // Choose the location that is later in the file.
  156|   606k|  const Location& a_loc = a.second.loc;
  157|   606k|  const Location& b_loc = b.second.loc;
  158|   606k|  const Location& loc = a_loc.line > b_loc.line ? a_loc : b_loc;
  ------------------
  |  Branch (158:25): [True: 0, False: 606k]
  ------------------
  159|   606k|  PrintError(&loc, "redefinition of %s \"%s\"", desc, a.first.c_str());
  160|   606k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver9VisitFuncEPNS_4FuncE:
  504|   870k|void NameResolver::VisitFunc(Func* func) {
  505|   870k|  current_func_ = func;
  506|   870k|  if (func->decl.has_func_type) {
  ------------------
  |  Branch (506:7): [True: 2.75k, False: 868k]
  ------------------
  507|  2.75k|    ResolveFuncTypeVar(&func->decl.type_var);
  508|  2.75k|  }
  509|       |
  510|   870k|  func->bindings.FindDuplicates([func, this](const BindingHash::value_type& a,
  511|   870k|                                             const BindingHash::value_type& b) {
  512|   870k|    const char* desc =
  513|   870k|        (a.second.index < func->GetNumParams()) ? "parameter" : "local";
  514|   870k|    PrintDuplicateBindingsError(a, b, desc);
  515|   870k|  });
  516|       |
  517|   870k|  visitor_.VisitFunc(func);
  518|   870k|  current_func_ = nullptr;
  519|   870k|}
resolve-names.cc:_ZZN4wabt12_GLOBAL__N_112NameResolver9VisitFuncEPNS_4FuncEENK3$_0clERKNSt3__14pairIKNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS_7BindingEEESH_:
  511|  11.8k|                                             const BindingHash::value_type& b) {
  512|  11.8k|    const char* desc =
  513|  11.8k|        (a.second.index < func->GetNumParams()) ? "parameter" : "local";
  ------------------
  |  Branch (513:9): [True: 698, False: 11.1k]
  ------------------
  514|  11.8k|    PrintDuplicateBindingsError(a, b, desc);
  515|  11.8k|  });
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11VisitExportEPNS_6ExportE:
  521|  9.22k|void NameResolver::VisitExport(Export* export_) {
  522|  9.22k|  switch (export_->kind) {
  ------------------
  |  Branch (522:11): [True: 0, False: 9.22k]
  ------------------
  523|  5.43k|    case ExternalKind::Func:
  ------------------
  |  Branch (523:5): [True: 5.43k, False: 3.78k]
  ------------------
  524|  5.43k|      ResolveFuncVar(&export_->var);
  525|  5.43k|      break;
  526|       |
  527|    975|    case ExternalKind::Table:
  ------------------
  |  Branch (527:5): [True: 975, False: 8.24k]
  ------------------
  528|    975|      ResolveTableVar(&export_->var);
  529|    975|      break;
  530|       |
  531|    891|    case ExternalKind::Memory:
  ------------------
  |  Branch (531:5): [True: 891, False: 8.33k]
  ------------------
  532|    891|      ResolveMemoryVar(&export_->var);
  533|    891|      break;
  534|       |
  535|  1.18k|    case ExternalKind::Global:
  ------------------
  |  Branch (535:5): [True: 1.18k, False: 8.04k]
  ------------------
  536|  1.18k|      ResolveGlobalVar(&export_->var);
  537|  1.18k|      break;
  538|       |
  539|    738|    case ExternalKind::Tag:
  ------------------
  |  Branch (539:5): [True: 738, False: 8.48k]
  ------------------
  540|    738|      ResolveTagVar(&export_->var);
  541|    738|      break;
  542|  9.22k|  }
  543|  9.22k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver11VisitGlobalEPNS_6GlobalE:
  545|   120k|void NameResolver::VisitGlobal(Global* global) {
  546|   120k|  visitor_.VisitExprList(global->init_expr);
  547|   120k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver8VisitTagEPNS_3TagE:
  549|  61.8k|void NameResolver::VisitTag(Tag* tag) {
  550|  61.8k|  if (tag->decl.has_func_type) {
  ------------------
  |  Branch (550:7): [True: 1.00k, False: 60.8k]
  ------------------
  551|  1.00k|    ResolveFuncTypeVar(&tag->decl.type_var);
  552|  1.00k|  }
  553|  61.8k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16VisitElemSegmentEPNS_11ElemSegmentE:
  555|   209k|void NameResolver::VisitElemSegment(ElemSegment* segment) {
  556|   209k|  ResolveTableVar(&segment->table_var);
  557|   209k|  visitor_.VisitExprList(segment->offset);
  558|   209k|  for (ExprList& elem_expr : segment->elem_exprs) {
  ------------------
  |  Branch (558:28): [True: 134k, False: 209k]
  ------------------
  559|   134k|    if (elem_expr.size() == 1 &&
  ------------------
  |  Branch (559:9): [True: 133k, False: 204]
  ------------------
  560|   134k|        elem_expr.front().type() == ExprType::RefFunc) {
  ------------------
  |  Branch (560:9): [True: 133k, False: 350]
  ------------------
  561|   133k|      ResolveFuncVar(&cast<RefFuncExpr>(&elem_expr.front())->var);
  562|   133k|    }
  563|   134k|  }
  564|   209k|}
resolve-names.cc:_ZN4wabt12_GLOBAL__N_112NameResolver16VisitDataSegmentEPNS_11DataSegmentE:
  566|  58.9k|void NameResolver::VisitDataSegment(DataSegment* segment) {
  567|  58.9k|  ResolveMemoryVar(&segment->memory_var);
  568|  58.9k|  visitor_.VisitExprList(segment->offset);
  569|  58.9k|}

_ZN4wabt16GetTokenTypeNameENS_9TokenTypeE:
   21|  4.46M|const char* GetTokenTypeName(TokenType token_type) {
   22|  4.46M|  static const char* s_names[] = {
   23|  4.46M|#define WABT_TOKEN(name, string) string,
   24|  4.46M|#define WABT_TOKEN_FIRST(name, string)
   25|  4.46M|#define WABT_TOKEN_LAST(name, string)
   26|  4.46M|#include "wabt/token.def"
  ------------------
  |  |    1|       |/*
  |  |    2|       | * Copyright 2018 WebAssembly Community Group participants
  |  |    3|       | *
  |  |    4|       | * Licensed under the Apache License, Version 2.0 (the "License");
  |  |    5|       | * you may not use this file except in compliance with the License.
  |  |    6|       | * You may obtain a copy of the License at
  |  |    7|       | *
  |  |    8|       | *     http://www.apache.org/licenses/LICENSE-2.0
  |  |    9|       | *
  |  |   10|       | * Unless required by applicable law or agreed to in writing, software
  |  |   11|       | * distributed under the License is distributed on an "AS IS" BASIS,
  |  |   12|       | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  |  |   13|       | * See the License for the specific language governing permissions and
  |  |   14|       | * limitations under the License.
  |  |   15|       | */
  |  |   16|       |
  |  |   17|       |#ifndef WABT_TOKEN
  |  |   18|       |#error "You must define WABT_TOKEN before including this file."
  |  |   19|       |#endif
  |  |   20|       |
  |  |   21|       |/* Tokens with no additional data (i.e. bare). */
  |  |   22|  4.46M|WABT_TOKEN(Invalid, "Invalid")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   23|  4.46M|WABT_TOKEN(After, "after")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   24|  4.46M|WABT_TOKEN(Array, "array")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   25|  4.46M|WABT_TOKEN(AssertException, "assert_exception")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   26|  4.46M|WABT_TOKEN(AssertExhaustion, "assert_exhaustion")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   27|  4.46M|WABT_TOKEN(AssertInvalid, "assert_invalid")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   28|  4.46M|WABT_TOKEN(AssertMalformed, "assert_malformed")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   29|  4.46M|WABT_TOKEN(AssertReturn, "assert_return")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   30|  4.46M|WABT_TOKEN(AssertTrap, "assert_trap")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   31|  4.46M|WABT_TOKEN(AssertUnlinkable, "assert_unlinkable")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   32|  4.46M|WABT_TOKEN(Before, "before")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   33|  4.46M|WABT_TOKEN(Bin, "bin")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   34|  4.46M|WABT_TOKEN(Item, "item")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   35|  4.46M|WABT_TOKEN(Data, "data")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   36|  4.46M|WABT_TOKEN(Declare, "declare")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   37|  4.46M|WABT_TOKEN(Delegate, "delegate")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   38|  4.46M|WABT_TOKEN(Do, "do")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   39|  4.46M|WABT_TOKEN(Either, "either")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   40|  4.46M|WABT_TOKEN(Elem, "elem")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   41|  4.46M|WABT_TOKEN(Eof, "EOF")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   42|  4.46M|WABT_TOKEN(Tag, "tag")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   43|  4.46M|WABT_TOKEN(Export, "export")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   44|  4.46M|WABT_TOKEN(Field, "field")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   45|  4.46M|WABT_TOKEN(Function, "function")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   46|  4.46M|WABT_TOKEN(Get, "get")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   47|  4.46M|WABT_TOKEN(Global, "global")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   48|  4.46M|WABT_TOKEN(Import, "import")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   49|  4.46M|WABT_TOKEN(Invoke, "invoke")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   50|  4.46M|WABT_TOKEN(Input, "input")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   51|  4.46M|WABT_TOKEN(Local, "local")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   52|  4.46M|WABT_TOKEN(Lpar, "(")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   53|  4.46M|WABT_TOKEN(Memory, "memory")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   54|  4.46M|WABT_TOKEN(Module, "module")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   55|  4.46M|WABT_TOKEN(Mut, "mut")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   56|  4.46M|WABT_TOKEN(NanArithmetic, "nan:arithmetic")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   57|  4.46M|WABT_TOKEN(NanCanonical, "nan:canonical")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   58|  4.46M|WABT_TOKEN(Offset, "offset")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   59|  4.46M|WABT_TOKEN(Output, "output")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   60|  4.46M|WABT_TOKEN(PageSize, "pagesize")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   61|  4.46M|WABT_TOKEN(Param, "param")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   62|  4.46M|WABT_TOKEN(Ref, "ref")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   63|  4.46M|WABT_TOKEN(Quote, "quote")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   64|  4.46M|WABT_TOKEN(Register, "register")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   65|  4.46M|WABT_TOKEN(Result, "result")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   66|  4.46M|WABT_TOKEN(Rpar, ")")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   67|  4.46M|WABT_TOKEN(Shared, "shared")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   68|  4.46M|WABT_TOKEN(Start, "start")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   69|  4.46M|WABT_TOKEN(Struct, "struct")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   70|  4.46M|WABT_TOKEN(Table, "table")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   71|  4.46M|WABT_TOKEN(Then, "then")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   72|  4.46M|WABT_TOKEN(Type, "type")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   73|  4.46M|WABT_TOKEN(I8X16, "i8x16")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   74|  4.46M|WABT_TOKEN(I16X8, "i16x8")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   75|  4.46M|WABT_TOKEN(I32X4, "i32x4")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   76|  4.46M|WABT_TOKEN(I64X2, "i64x2")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   77|  4.46M|WABT_TOKEN(F32X4, "f32x4")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   78|  4.46M|WABT_TOKEN(F64X2, "f64x2")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   79|  4.46M|WABT_TOKEN_FIRST(Bare, Invalid)
  |  |   80|  4.46M|WABT_TOKEN_LAST(Bare, F64X2)
  |  |   81|       |
  |  |   82|       |/* Tokens with Literal data. */
  |  |   83|  4.46M|WABT_TOKEN(Float, "FLOAT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   84|  4.46M|WABT_TOKEN(Int, "INT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   85|  4.46M|WABT_TOKEN(Nat, "NAT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   86|  4.46M|WABT_TOKEN_FIRST(Literal, Float)
  |  |   87|  4.46M|WABT_TOKEN_LAST(Literal, Nat)
  |  |   88|       |
  |  |   89|       |/* Tokens with Opcode data. */
  |  |   90|  4.46M|WABT_TOKEN(AtomicFence, "atomic.fence")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   91|  4.46M|WABT_TOKEN(AtomicLoad, "ATOMIC_LOAD")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   92|  4.46M|WABT_TOKEN(AtomicNotify, "ATOMIC_NOTIFY")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   93|  4.46M|WABT_TOKEN(AtomicRmw, "ATOMIC_RMW")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   94|  4.46M|WABT_TOKEN(AtomicRmwCmpxchg, "ATOMIC_RMW_CMPXCHG")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   95|  4.46M|WABT_TOKEN(AtomicStore, "ATOMIC_STORE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   96|  4.46M|WABT_TOKEN(AtomicWait, "ATOMIC_WAIT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   97|  4.46M|WABT_TOKEN(Binary, "BINARY")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   98|  4.46M|WABT_TOKEN(Block, "block")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |   99|  4.46M|WABT_TOKEN(Br, "br")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  100|  4.46M|WABT_TOKEN(BrIf, "br_if")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  101|  4.46M|WABT_TOKEN(BrTable, "br_table")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  102|  4.46M|WABT_TOKEN(Code, "code")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  103|  4.46M|WABT_TOKEN(Call, "call")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  104|  4.46M|WABT_TOKEN(CallIndirect, "call_indirect")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  105|  4.46M|WABT_TOKEN(CallRef, "call_ref")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  106|  4.46M|WABT_TOKEN(Catch, "catch")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  107|  4.46M|WABT_TOKEN(CatchAll, "catch_all")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  108|  4.46M|WABT_TOKEN(CatchRef, "catch_ref")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  109|  4.46M|WABT_TOKEN(CatchAllRef, "catch_all_ref")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  110|  4.46M|WABT_TOKEN(Compare, "COMPARE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  111|  4.46M|WABT_TOKEN(Const, "CONST")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  112|  4.46M|WABT_TOKEN(Convert, "CONVERT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  113|  4.46M|WABT_TOKEN(DataDrop, "data.drop")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  114|  4.46M|WABT_TOKEN(Drop, "drop")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  115|  4.46M|WABT_TOKEN(ElemDrop, "elem.drop")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  116|  4.46M|WABT_TOKEN(Else, "else")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  117|  4.46M|WABT_TOKEN(End, "end")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  118|  4.46M|WABT_TOKEN(GlobalGet, "global.get")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  119|  4.46M|WABT_TOKEN(GlobalSet, "global.set")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  120|  4.46M|WABT_TOKEN(If, "if")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  121|  4.46M|WABT_TOKEN(Load, "LOAD")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  122|  4.46M|WABT_TOKEN(LocalGet, "local.get")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  123|  4.46M|WABT_TOKEN(LocalSet, "local.set")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  124|  4.46M|WABT_TOKEN(LocalTee, "local.tee")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  125|  4.46M|WABT_TOKEN(Loop, "loop")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  126|  4.46M|WABT_TOKEN(MemoryCopy, "memory.copy")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  127|  4.46M|WABT_TOKEN(MemoryFill, "memory.fill")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  128|  4.46M|WABT_TOKEN(MemoryGrow, "memory.grow")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  129|  4.46M|WABT_TOKEN(MemoryInit, "memory.init")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  130|  4.46M|WABT_TOKEN(MemorySize, "memory.size")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  131|  4.46M|WABT_TOKEN(Nop, "nop")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  132|  4.46M|WABT_TOKEN(RefExtern, "ref.extern")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  133|  4.46M|WABT_TOKEN(RefFunc, "ref.func")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  134|  4.46M|WABT_TOKEN(RefIsNull, "ref.is_null")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  135|  4.46M|WABT_TOKEN(RefNull, "ref.null")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  136|  4.46M|WABT_TOKEN(Rethrow, "rethrow")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  137|  4.46M|WABT_TOKEN(ReturnCallIndirect, "return_call_indirect")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  138|  4.46M|WABT_TOKEN(ReturnCall, "return_call")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  139|  4.46M|WABT_TOKEN(Return, "return")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  140|  4.46M|WABT_TOKEN(Select, "select")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  141|  4.46M|WABT_TOKEN(SimdLaneOp, "SIMDLANEOP")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  142|  4.46M|WABT_TOKEN(SimdLoadSplat, "SIMDLOADSPLAT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  143|  4.46M|WABT_TOKEN(SimdLoadLane, "SIMDLOADLANE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  144|  4.46M|WABT_TOKEN(SimdStoreLane, "SIMDSTORELANE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  145|  4.46M|WABT_TOKEN(SimdShuffleOp, "i8x16.shuffle")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  146|  4.46M|WABT_TOKEN(Store, "STORE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  147|  4.46M|WABT_TOKEN(TableCopy, "table.copy")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  148|  4.46M|WABT_TOKEN(TableFill, "table.fill")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  149|  4.46M|WABT_TOKEN(TableGet, "table.get")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  150|  4.46M|WABT_TOKEN(TableGrow, "table.grow")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  151|  4.46M|WABT_TOKEN(TableInit, "table.init")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  152|  4.46M|WABT_TOKEN(TableSet, "table.set")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  153|  4.46M|WABT_TOKEN(TableSize, "table.size")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  154|  4.46M|WABT_TOKEN(Ternary, "TERNARY")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  155|  4.46M|WABT_TOKEN(Throw, "throw")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  156|  4.46M|WABT_TOKEN(ThrowRef, "throw_ref")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  157|  4.46M|WABT_TOKEN(Try, "try")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  158|  4.46M|WABT_TOKEN(TryTable, "try_table")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  159|  4.46M|WABT_TOKEN(Unary, "UNARY")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  160|  4.46M|WABT_TOKEN(Unreachable, "unreachable")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  161|  4.46M|WABT_TOKEN_FIRST(Opcode, AtomicFence)
  |  |  162|  4.46M|WABT_TOKEN_LAST(Opcode, Unreachable)
  |  |  163|       |
  |  |  164|       |/* Tokens with string data. */
  |  |  165|  4.46M|WABT_TOKEN(AlignEqNat, "align=")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  166|  4.46M|WABT_TOKEN(LparAnn, "Annotation")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  167|  4.46M|WABT_TOKEN(OffsetEqNat, "offset=")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  168|  4.46M|WABT_TOKEN(Reserved, "Reserved")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  169|  4.46M|WABT_TOKEN(Text, "TEXT")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  170|  4.46M|WABT_TOKEN(Var, "VAR")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  171|  4.46M|WABT_TOKEN_FIRST(String, AlignEqNat)
  |  |  172|  4.46M|WABT_TOKEN_LAST(String, Var)
  |  |  173|       |
  |  |  174|       |/* Tokens with Type data. */
  |  |  175|  4.46M|WABT_TOKEN(ValueType, "VALUETYPE")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  176|  4.46M|WABT_TOKEN_FIRST(Type, ValueType)
  |  |  177|  4.46M|WABT_TOKEN_LAST(Type, ValueType)
  |  |  178|       |
  |  |  179|       |/* Tokens with Type data, but are reference kinds. */
  |  |  180|  4.46M|WABT_TOKEN(Func, "func")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  181|  4.46M|WABT_TOKEN(Extern, "extern")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  182|  4.46M|WABT_TOKEN(Exn, "exn")
  |  |  ------------------
  |  |  |  |   23|  4.46M|#define WABT_TOKEN(name, string) string,
  |  |  ------------------
  |  |  183|  4.46M|WABT_TOKEN_FIRST(RefKind, Func)
  |  |  184|  4.46M|WABT_TOKEN_LAST(RefKind, Exn)
  ------------------
   27|  4.46M|#undef WABT_TOKEN
   28|  4.46M|#undef WABT_TOKEN_FIRST
   29|  4.46M|#undef WABT_TOKEN_LAST
   30|  4.46M|  };
   31|       |
   32|  4.46M|  static_assert(
   33|  4.46M|      WABT_ARRAY_SIZE(s_names) == WABT_ENUM_COUNT(TokenType),
   34|  4.46M|      "Expected TokenType names list length to match number of TokenTypes.");
   35|       |
   36|  4.46M|  int x = static_cast<int>(token_type);
   37|  4.46M|  if (x < WABT_ENUM_COUNT(TokenType)) {
  ------------------
  |  |   61|  4.46M|  (static_cast<int>(name::Last) - static_cast<int>(name::First) + 1)
  ------------------
  |  Branch (37:7): [True: 4.46M, False: 0]
  ------------------
   38|  4.46M|    return s_names[x];
   39|  4.46M|  }
   40|       |
   41|      0|  return "Invalid";
   42|  4.46M|}
_ZN4wabt5TokenC2ENS_8LocationENS_9TokenTypeE:
   45|  15.0M|    : loc(loc), token_type_(token_type) {
   46|  15.0M|  assert(IsTokenTypeBare(token_type_));
   47|  15.0M|}
_ZN4wabt5TokenC2ENS_8LocationENS_9TokenTypeENS_4TypeE:
   50|  2.91M|    : loc(loc), token_type_(token_type) {
   51|  2.91M|  assert(HasType());
   52|  2.91M|  Construct(type_, type);
   53|  2.91M|}
_ZN4wabt5TokenC2ENS_8LocationENS_9TokenTypeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|  7.70M|    : loc(loc), token_type_(token_type) {
   57|  7.70M|  assert(HasText());
   58|  7.70M|  Construct(text_, text);
   59|  7.70M|}
_ZN4wabt5TokenC2ENS_8LocationENS_9TokenTypeENS_6OpcodeE:
   62|  1.24M|    : loc(loc), token_type_(token_type) {
   63|  1.24M|  assert(HasOpcode());
   64|  1.24M|  Construct(opcode_, opcode);
   65|  1.24M|}
_ZN4wabt5TokenC2ENS_8LocationENS_9TokenTypeERKNS_7LiteralE:
   68|  1.54M|    : loc(loc), token_type_(token_type) {
   69|  1.54M|  assert(HasLiteral());
   70|  1.54M|  Construct(literal_, literal);
   71|  1.54M|}
_ZNK4wabt5Token9to_stringEv:
   73|  5.69M|std::string Token::to_string() const {
   74|  5.69M|  if (IsTokenTypeBare(token_type_)) {
  ------------------
  |  Branch (74:7): [True: 1.83M, False: 3.85M]
  ------------------
   75|  1.83M|    return GetTokenTypeName(token_type_);
   76|  3.85M|  } else if (HasLiteral()) {
  ------------------
  |  Branch (76:14): [True: 135k, False: 3.72M]
  ------------------
   77|   135k|    return std::string(literal_.text);
   78|  3.72M|  } else if (HasOpcode()) {
  ------------------
  |  Branch (78:14): [True: 11.4k, False: 3.71M]
  ------------------
   79|  11.4k|    return opcode_.GetName();
   80|  3.71M|  } else if (HasText()) {
  ------------------
  |  Branch (80:14): [True: 3.63M, False: 78.6k]
  ------------------
   81|  3.63M|    return std::string(text_);
   82|  3.63M|  } else if (IsTokenTypeRefKind(token_type_)) {
  ------------------
  |  Branch (82:14): [True: 65.8k, False: 12.8k]
  ------------------
   83|  65.8k|    return type_.GetRefKindName();
   84|  65.8k|  } else {
   85|  12.8k|    assert(HasType());
   86|  12.8k|    return type_.GetName();
   87|  12.8k|  }
   88|  5.69M|}
_ZNK4wabt5Token15to_string_clampEm:
   90|  4.56M|std::string Token::to_string_clamp(size_t max_length) const {
   91|  4.56M|  std::string s = to_string();
   92|  4.56M|  if (s.length() > max_length) {
  ------------------
  |  Branch (92:7): [True: 45.5k, False: 4.51M]
  ------------------
   93|  45.5k|    return s.substr(0, max_length - 3) + "...";
   94|  4.51M|  } else {
   95|  4.51M|    return s;
   96|  4.51M|  }
   97|  4.56M|}

_ZN4wabt11IsValidUtf8EPKcm:
   54|   494k|bool IsValidUtf8(const char* s, size_t s_length) {
   55|   494k|  const uint8_t* p = reinterpret_cast<const uint8_t*>(s);
   56|   494k|  const uint8_t* end = p + s_length;
   57|   746k|  while (p < end) {
  ------------------
  |  Branch (57:10): [True: 262k, False: 483k]
  ------------------
   58|   262k|    uint8_t cu0 = *p;
   59|   262k|    int length = s_utf8_length[cu0];
   60|   262k|    if (p + length > end) {
  ------------------
  |  Branch (60:9): [True: 301, False: 262k]
  ------------------
   61|    301|      return false;
   62|    301|    }
   63|       |
   64|   262k|    switch (length) {
  ------------------
  |  Branch (64:13): [True: 0, False: 262k]
  ------------------
   65|  2.47k|      case 0:
  ------------------
  |  Branch (65:7): [True: 2.47k, False: 260k]
  ------------------
   66|  2.47k|        return false;
   67|       |
   68|   249k|      case 1:
  ------------------
  |  Branch (68:7): [True: 249k, False: 13.2k]
  ------------------
   69|   249k|        p++;
   70|   249k|        break;
   71|       |
   72|  6.77k|      case 2:
  ------------------
  |  Branch (72:7): [True: 6.77k, False: 255k]
  ------------------
   73|  6.77k|        p++;
   74|  6.77k|        if (!IsCont(*p++)) {
  ------------------
  |  Branch (74:13): [True: 6.51k, False: 261]
  ------------------
   75|  6.51k|          return false;
   76|  6.51k|        }
   77|    261|        break;
   78|       |
   79|  1.94k|      case 3: {
  ------------------
  |  Branch (79:7): [True: 1.94k, False: 260k]
  ------------------
   80|  1.94k|        p++;
   81|  1.94k|        uint8_t cu1 = *p++;
   82|  1.94k|        uint8_t cu2 = *p++;
   83|  1.94k|        if (!(IsCont(cu1) && IsCont(cu2)) ||
  ------------------
  |  Branch (83:15): [True: 1.57k, False: 376]
  |  Branch (83:30): [True: 1.11k, False: 460]
  ------------------
   84|  1.94k|            (cu0 == 0xe0 && cu1 < 0xa0) ||  // Overlong encoding.
  ------------------
  |  Branch (84:14): [True: 473, False: 639]
  |  Branch (84:29): [True: 200, False: 273]
  ------------------
   85|  1.94k|            (cu0 == 0xed && cu1 >= 0xa0))   // UTF-16 surrogate halves.
  ------------------
  |  Branch (85:14): [True: 490, False: 422]
  |  Branch (85:29): [True: 194, False: 296]
  ------------------
   86|  1.23k|          return false;
   87|    718|        break;
   88|  1.94k|      }
   89|       |
   90|  2.02k|      case 4: {
  ------------------
  |  Branch (90:7): [True: 2.02k, False: 260k]
  ------------------
   91|  2.02k|        p++;
   92|  2.02k|        uint8_t cu1 = *p++;
   93|  2.02k|        uint8_t cu2 = *p++;
   94|  2.02k|        uint8_t cu3 = *p++;
   95|  2.02k|        if (!(IsCont(cu1) && IsCont(cu2) && IsCont(cu3)) ||
  ------------------
  |  Branch (95:15): [True: 1.61k, False: 409]
  |  Branch (95:30): [True: 1.41k, False: 202]
  |  Branch (95:45): [True: 1.21k, False: 199]
  ------------------
   96|  2.02k|            (cu0 == 0xf0 && cu1 < 0x90) ||  // Overlong encoding.
  ------------------
  |  Branch (96:14): [True: 567, False: 650]
  |  Branch (96:29): [True: 199, False: 368]
  ------------------
   97|  2.02k|            (cu0 == 0xf4 && cu1 >= 0x90))   // Code point >= 0x11000.
  ------------------
  |  Branch (97:14): [True: 429, False: 589]
  |  Branch (97:29): [True: 214, False: 215]
  ------------------
   98|  1.22k|          return false;
   99|    804|        break;
  100|  2.02k|      }
  101|   262k|    }
  102|   262k|  }
  103|   483k|  return true;
  104|   494k|}
utf8.cc:_ZN4wabt12_GLOBAL__N_16IsContEh:
   48|  15.3k|bool IsCont(uint8_t c) {
   49|  15.3k|  return (c & 0xc0) == 0x80;
   50|  15.3k|}

_ZN4wabt9WastLexerC2ENSt3__110unique_ptrINS_11LexerSourceENS1_14default_deleteIS3_EEEENS1_17basic_string_viewIcNS1_11char_traitsIcEEEEPNS1_6vectorINS_5ErrorENS1_9allocatorISC_EEEE:
   46|  23.2k|    : source_(std::move(source)),
   47|  23.2k|      filename_(filename),
   48|  23.2k|      line_(1),
   49|  23.2k|      buffer_(static_cast<const char*>(source_->data())),
   50|  23.2k|      buffer_end_(buffer_ + source_->size()),
   51|  23.2k|      line_start_(buffer_),
   52|  23.2k|      token_start_(buffer_),
   53|  23.2k|      cursor_(buffer_),
   54|  23.2k|      errors_(errors) {}
_ZN4wabt9WastLexer17CreateBufferLexerENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKvmPNS1_6vectorINS_5ErrorENS1_9allocatorIS9_EEEE:
   61|  23.2k|    Errors* errors) {
   62|  23.2k|  return std::make_unique<WastLexer>(std::make_unique<LexerSource>(data, size),
   63|  23.2k|                                     filename, errors);
   64|  23.2k|}
_ZN4wabt9WastLexer8GetTokenEv:
   66|  25.5M|Token WastLexer::GetToken() {
   67|  43.3M|  while (true) {
  ------------------
  |  Branch (67:10): [Folded - Ignored]
  ------------------
   68|  43.3M|    token_start_ = cursor_;
   69|  43.3M|    switch (PeekChar()) {
   70|  1.62M|      case kEof:
  ------------------
  |  Branch (70:7): [True: 1.62M, False: 41.7M]
  ------------------
   71|  1.62M|        return BareToken(TokenType::Eof);
   72|       |
   73|  8.30M|      case '(':
  ------------------
  |  Branch (73:7): [True: 8.30M, False: 35.0M]
  ------------------
   74|  8.30M|        if (MatchString("(;")) {
  ------------------
  |  Branch (74:13): [True: 359, False: 8.30M]
  ------------------
   75|    359|          if (ReadBlockComment()) {
  ------------------
  |  Branch (75:15): [True: 217, False: 142]
  ------------------
   76|    217|            continue;
   77|    217|          }
   78|    142|          return BareToken(TokenType::Eof);
   79|  8.30M|        } else if (MatchString("(@")) {
  ------------------
  |  Branch (79:20): [True: 1.10M, False: 7.20M]
  ------------------
   80|  1.10M|          GetIdChars();
   81|       |          // offset=2 to skip the "(@" prefix
   82|  1.10M|          return TextToken(TokenType::LparAnn, 2);
   83|  7.20M|        } else {
   84|  7.20M|          ReadChar();
   85|  7.20M|          return BareToken(TokenType::Lpar);
   86|  7.20M|        }
   87|      0|        break;
   88|       |
   89|  1.84M|      case ')':
  ------------------
  |  Branch (89:7): [True: 1.84M, False: 41.5M]
  ------------------
   90|  1.84M|        ReadChar();
   91|  1.84M|        return BareToken(TokenType::Rpar);
   92|       |
   93|   407k|      case ';':
  ------------------
  |  Branch (93:7): [True: 407k, False: 42.9M]
  ------------------
   94|   407k|        if (MatchString(";;")) {
  ------------------
  |  Branch (94:13): [True: 1.01k, False: 406k]
  ------------------
   95|  1.01k|          if (ReadLineComment()) {
  ------------------
  |  Branch (95:15): [True: 1.00k, False: 15]
  ------------------
   96|  1.00k|            continue;
   97|  1.00k|          }
   98|     15|          return BareToken(TokenType::Eof);
   99|   406k|        } else {
  100|   406k|          ReadChar();
  101|   406k|          ERROR("unexpected char");
  ------------------
  |  |   26|   406k|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  102|   406k|          continue;
  103|   406k|        }
  104|      0|        break;
  105|       |
  106|   230k|      case ' ':
  ------------------
  |  Branch (106:7): [True: 230k, False: 43.1M]
  ------------------
  107|   257k|      case '\t':
  ------------------
  |  Branch (107:7): [True: 26.5k, False: 43.3M]
  ------------------
  108|   343k|      case '\r':
  ------------------
  |  Branch (108:7): [True: 85.8k, False: 43.2M]
  ------------------
  109|   931k|      case '\n':
  ------------------
  |  Branch (109:7): [True: 587k, False: 42.7M]
  ------------------
  110|   931k|        ReadWhitespace();
  111|   931k|        continue;
  112|       |
  113|   642k|      case '"':
  ------------------
  |  Branch (113:7): [True: 642k, False: 42.7M]
  ------------------
  114|   642k|        return GetStringToken();
  115|       |
  116|  63.1k|      case '+':
  ------------------
  |  Branch (116:7): [True: 63.1k, False: 43.3M]
  ------------------
  117|   171k|      case '-':
  ------------------
  |  Branch (117:7): [True: 108k, False: 43.2M]
  ------------------
  118|   171k|        ReadChar();
  119|   171k|        switch (PeekChar()) {
  120|  1.49k|          case 'i':
  ------------------
  |  Branch (120:11): [True: 1.49k, False: 170k]
  ------------------
  121|  1.49k|            return GetInfToken();
  122|       |
  123|  10.4k|          case 'n':
  ------------------
  |  Branch (123:11): [True: 10.4k, False: 161k]
  ------------------
  124|  10.4k|            return GetNanToken();
  125|       |
  126|  8.73k|          case '0':
  ------------------
  |  Branch (126:11): [True: 8.73k, False: 162k]
  ------------------
  127|  8.73k|            return MatchString("0x") ? GetHexNumberToken(TokenType::Int)
  ------------------
  |  Branch (127:20): [True: 5.95k, False: 2.77k]
  ------------------
  128|  8.73k|                                     : GetNumberToken(TokenType::Int);
  129|  10.4k|          case '1':
  ------------------
  |  Branch (129:11): [True: 10.4k, False: 161k]
  ------------------
  130|  12.3k|          case '2':
  ------------------
  |  Branch (130:11): [True: 1.88k, False: 169k]
  ------------------
  131|  28.9k|          case '3':
  ------------------
  |  Branch (131:11): [True: 16.6k, False: 154k]
  ------------------
  132|  38.3k|          case '4':
  ------------------
  |  Branch (132:11): [True: 9.32k, False: 162k]
  ------------------
  133|  39.0k|          case '5':
  ------------------
  |  Branch (133:11): [True: 721, False: 170k]
  ------------------
  134|  39.8k|          case '6':
  ------------------
  |  Branch (134:11): [True: 796, False: 170k]
  ------------------
  135|  42.3k|          case '7':
  ------------------
  |  Branch (135:11): [True: 2.52k, False: 169k]
  ------------------
  136|  46.0k|          case '8':
  ------------------
  |  Branch (136:11): [True: 3.67k, False: 167k]
  ------------------
  137|  46.2k|          case '9':
  ------------------
  |  Branch (137:11): [True: 237, False: 171k]
  ------------------
  138|  46.2k|            return GetNumberToken(TokenType::Int);
  139|       |
  140|   104k|          default:
  ------------------
  |  Branch (140:11): [True: 104k, False: 66.9k]
  ------------------
  141|   104k|            return GetReservedToken();
  142|   171k|        }
  143|      0|        break;
  144|       |
  145|   557k|      case '0':
  ------------------
  |  Branch (145:7): [True: 557k, False: 42.8M]
  ------------------
  146|   557k|        return MatchString("0x") ? GetHexNumberToken(TokenType::Nat)
  ------------------
  |  Branch (146:16): [True: 268k, False: 288k]
  ------------------
  147|   557k|                                 : GetNumberToken(TokenType::Nat);
  148|       |
  149|   529k|      case '1':
  ------------------
  |  Branch (149:7): [True: 529k, False: 42.8M]
  ------------------
  150|   594k|      case '2':
  ------------------
  |  Branch (150:7): [True: 65.2k, False: 43.3M]
  ------------------
  151|   884k|      case '3':
  ------------------
  |  Branch (151:7): [True: 289k, False: 43.0M]
  ------------------
  152|   910k|      case '4':
  ------------------
  |  Branch (152:7): [True: 26.1k, False: 43.3M]
  ------------------
  153|   931k|      case '5':
  ------------------
  |  Branch (153:7): [True: 21.1k, False: 43.3M]
  ------------------
  154|   957k|      case '6':
  ------------------
  |  Branch (154:7): [True: 26.1k, False: 43.3M]
  ------------------
  155|   971k|      case '7':
  ------------------
  |  Branch (155:7): [True: 13.3k, False: 43.3M]
  ------------------
  156|  1.01M|      case '8':
  ------------------
  |  Branch (156:7): [True: 39.7k, False: 43.3M]
  ------------------
  157|  1.01M|      case '9':
  ------------------
  |  Branch (157:7): [True: 2.95k, False: 43.3M]
  ------------------
  158|  1.01M|        return GetNumberToken(TokenType::Nat);
  159|       |
  160|  2.59M|      case '$':
  ------------------
  |  Branch (160:7): [True: 2.59M, False: 40.7M]
  ------------------
  161|  2.59M|        return GetIdChars();  // Initial $ is idchar, so this produces id token
  162|       |
  163|  37.3k|      case 'a':
  ------------------
  |  Branch (163:7): [True: 37.3k, False: 43.3M]
  ------------------
  164|  37.3k|        return GetNameEqNumToken("align=", TokenType::AlignEqNat);
  165|       |
  166|  1.39M|      case 'i':
  ------------------
  |  Branch (166:7): [True: 1.39M, False: 41.9M]
  ------------------
  167|  1.39M|        return GetInfToken();
  168|       |
  169|   267k|      case 'n':
  ------------------
  |  Branch (169:7): [True: 267k, False: 43.1M]
  ------------------
  170|   267k|        return GetNanToken();
  171|       |
  172|  58.0k|      case 'o':
  ------------------
  |  Branch (172:7): [True: 58.0k, False: 43.3M]
  ------------------
  173|  58.0k|        return GetNameEqNumToken("offset=", TokenType::OffsetEqNat);
  174|       |
  175|  23.5M|      default:
  ------------------
  |  Branch (175:7): [True: 23.5M, False: 19.8M]
  ------------------
  176|  23.5M|        if (IsKeyword(PeekChar())) {
  ------------------
  |  Branch (176:13): [True: 6.73M, False: 16.7M]
  ------------------
  177|  6.73M|          return GetKeywordToken();
  178|  16.7M|        } else if (IsIdChar(PeekChar())) {
  ------------------
  |  Branch (178:20): [True: 296k, False: 16.4M]
  ------------------
  179|   296k|          return GetReservedToken();
  180|  16.4M|        } else {
  181|  16.4M|          ReadChar();
  182|  16.4M|          ERROR("unexpected char");
  ------------------
  |  |   26|  16.4M|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  183|  16.4M|          continue;
  184|  16.4M|        }
  185|  43.3M|    }
  186|  43.3M|  }
  187|  25.5M|}
_ZN4wabt9WastLexer11GetLocationEv:
  189|  48.6M|Location WastLexer::GetLocation() {
  190|  48.6M|  auto column = [this](const char* p) {
  191|  48.6M|    return std::max(1, static_cast<int>(p - line_start_ + 1));
  192|  48.6M|  };
  193|  48.6M|  return Location(filename_, line_, column(token_start_), column(cursor_));
  194|  48.6M|}
_ZN4wabt9WastLexer7GetTextEm:
  196|  9.25M|std::string_view WastLexer::GetText(size_t offset) {
  197|       |  // Bounds checks are necessary because token_start may have been moved
  198|       |  // (e.g. if GetStringToken found a newline and reset token_start to
  199|       |  // point at it).
  200|       |
  201|  9.25M|  if (token_start_ + offset >= buffer_end_)
  ------------------
  |  Branch (201:7): [True: 101, False: 9.25M]
  ------------------
  202|    101|    return {};
  203|       |
  204|  9.25M|  if (cursor_ <= token_start_ + offset)
  ------------------
  |  Branch (204:7): [True: 1.04M, False: 8.21M]
  ------------------
  205|  1.04M|    return {};
  206|       |
  207|  8.21M|  return std::string_view(token_start_ + offset,
  208|  8.21M|                          (cursor_ - token_start_) - offset);
  209|  9.25M|}
_ZN4wabt9WastLexer9BareTokenENS_9TokenTypeE:
  211|  13.3M|Token WastLexer::BareToken(TokenType token_type) {
  212|  13.3M|  return Token(GetLocation(), token_type);
  213|  13.3M|}
_ZN4wabt9WastLexer12LiteralTokenENS_9TokenTypeENS_11LiteralTypeE:
  215|  1.54M|Token WastLexer::LiteralToken(TokenType token_type, LiteralType literal_type) {
  216|  1.54M|  return Token(GetLocation(), token_type, Literal(literal_type, GetText()));
  217|  1.54M|}
_ZN4wabt9WastLexer9TextTokenENS_9TokenTypeEm:
  219|  7.70M|Token WastLexer::TextToken(TokenType token_type, size_t offset) {
  220|  7.70M|  return Token(GetLocation(), token_type, GetText(offset));
  221|  7.70M|}
_ZN4wabt9WastLexer8PeekCharEv:
  223|   367M|int WastLexer::PeekChar() {
  224|   367M|  return cursor_ < buffer_end_ ? static_cast<uint8_t>(*cursor_) : kEof;
  ------------------
  |  Branch (224:10): [True: 365M, False: 1.65M]
  ------------------
  225|   367M|}
_ZN4wabt9WastLexer8ReadCharEv:
  227|   326M|int WastLexer::ReadChar() {
  228|   326M|  return cursor_ < buffer_end_ ? static_cast<uint8_t>(*cursor_++) : kEof;
  ------------------
  |  Branch (228:10): [True: 326M, False: 3.59k]
  ------------------
  229|   326M|}
_ZN4wabt9WastLexer9MatchCharEc:
  231|  24.9M|bool WastLexer::MatchChar(char c) {
  232|  24.9M|  if (PeekChar() == c) {
  ------------------
  |  Branch (232:7): [True: 826k, False: 24.1M]
  ------------------
  233|   826k|    ReadChar();
  234|   826k|    return true;
  235|   826k|  }
  236|  24.1M|  return false;
  237|  24.9M|}
_ZN4wabt9WastLexer11MatchStringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  239|  19.3M|bool WastLexer::MatchString(std::string_view s) {
  240|  19.3M|  const char* saved_cursor = cursor_;
  241|  39.0M|  for (char c : s) {
  ------------------
  |  Branch (241:15): [True: 39.0M, False: 1.53M]
  ------------------
  242|  39.0M|    if (ReadChar() != c) {
  ------------------
  |  Branch (242:9): [True: 17.8M, False: 21.1M]
  ------------------
  243|  17.8M|      cursor_ = saved_cursor;
  244|  17.8M|      return false;
  245|  17.8M|    }
  246|  39.0M|  }
  247|  1.53M|  return true;
  248|  19.3M|}
_ZN4wabt9WastLexer7NewlineEv:
  250|  68.2M|void WastLexer::Newline() {
  251|  68.2M|  line_++;
  252|  68.2M|  line_start_ = cursor_;
  253|  68.2M|}
_ZN4wabt9WastLexer16ReadBlockCommentEv:
  255|    359|bool WastLexer::ReadBlockComment() {
  256|    359|  int nesting = 1;
  257|  2.26M|  while (true) {
  ------------------
  |  Branch (257:10): [Folded - Ignored]
  ------------------
  258|  2.26M|    switch (ReadChar()) {
  ------------------
  |  Branch (258:13): [True: 1.22M, False: 1.04M]
  ------------------
  259|    142|      case kEof:
  ------------------
  |  Branch (259:7): [True: 142, False: 2.26M]
  ------------------
  260|    142|        ERROR("EOF in block comment");
  ------------------
  |  |   26|    142|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  261|    142|        return false;
  262|       |
  263|  55.9k|      case ';':
  ------------------
  |  Branch (263:7): [True: 55.9k, False: 2.21M]
  ------------------
  264|  55.9k|        if (MatchChar(')') && --nesting == 0) {
  ------------------
  |  Branch (264:13): [True: 18.9k, False: 37.0k]
  |  Branch (264:31): [True: 217, False: 18.7k]
  ------------------
  265|    217|          return true;
  266|    217|        }
  267|  55.7k|        break;
  268|       |
  269|   345k|      case '(':
  ------------------
  |  Branch (269:7): [True: 345k, False: 1.92M]
  ------------------
  270|   345k|        if (MatchChar(';')) {
  ------------------
  |  Branch (270:13): [True: 289k, False: 55.8k]
  ------------------
  271|   289k|          nesting++;
  272|   289k|        }
  273|   345k|        break;
  274|       |
  275|   644k|      case '\n':
  ------------------
  |  Branch (275:7): [True: 644k, False: 1.62M]
  ------------------
  276|   644k|        Newline();
  277|   644k|        break;
  278|  2.26M|    }
  279|  2.26M|  }
  280|    359|}
_ZN4wabt9WastLexer15ReadLineCommentEv:
  282|  1.01k|bool WastLexer::ReadLineComment() {
  283|  4.39k|  while (true) {
  ------------------
  |  Branch (283:10): [Folded - Ignored]
  ------------------
  284|  4.39k|    switch (ReadChar()) {
  ------------------
  |  Branch (284:13): [True: 3.37k, False: 1.01k]
  ------------------
  285|     15|      case kEof:
  ------------------
  |  Branch (285:7): [True: 15, False: 4.37k]
  ------------------
  286|     15|        return false;
  287|       |
  288|    743|      case '\r':
  ------------------
  |  Branch (288:7): [True: 743, False: 3.64k]
  ------------------
  289|    743|        if (PeekChar() == '\n') {
  ------------------
  |  Branch (289:13): [True: 439, False: 304]
  ------------------
  290|    439|          ReadChar();
  291|    439|        }
  292|    743|        Newline();
  293|    743|        return true;
  294|       |
  295|    261|      case '\n':
  ------------------
  |  Branch (295:7): [True: 261, False: 4.13k]
  ------------------
  296|    261|        Newline();
  297|    261|        return true;
  298|  4.39k|    }
  299|  4.39k|  }
  300|  1.01k|}
_ZN4wabt9WastLexer14ReadWhitespaceEv:
  302|   931k|void WastLexer::ReadWhitespace() {
  303|  65.3M|  while (true) {
  ------------------
  |  Branch (303:10): [Folded - Ignored]
  ------------------
  304|  65.3M|    switch (PeekChar()) {
  305|   232k|      case ' ':
  ------------------
  |  Branch (305:7): [True: 232k, False: 65.1M]
  ------------------
  306|   310k|      case '\t':
  ------------------
  |  Branch (306:7): [True: 78.1k, False: 65.2M]
  ------------------
  307|   397k|      case '\r':
  ------------------
  |  Branch (307:7): [True: 87.4k, False: 65.2M]
  ------------------
  308|   397k|        ReadChar();
  309|   397k|        break;
  310|       |
  311|  64.0M|      case '\n':
  ------------------
  |  Branch (311:7): [True: 64.0M, False: 1.32M]
  ------------------
  312|  64.0M|        ReadChar();
  313|  64.0M|        Newline();
  314|  64.0M|        break;
  315|       |
  316|   931k|      default:
  ------------------
  |  Branch (316:7): [True: 931k, False: 64.4M]
  ------------------
  317|   931k|        return;
  318|  65.3M|    }
  319|  65.3M|  }
  320|   931k|}
_ZN4wabt9WastLexer14GetStringTokenEv:
  322|  1.37M|Token WastLexer::GetStringToken() {
  323|  1.37M|  const char* saved_token_start = token_start_;
  324|  1.37M|  bool has_error = false;
  325|  1.37M|  bool in_string = true;
  326|  1.37M|  ReadChar();
  327|  37.6M|  while (in_string) {
  ------------------
  |  Branch (327:10): [True: 36.2M, False: 1.37M]
  ------------------
  328|  36.2M|    switch (ReadChar()) {
  ------------------
  |  Branch (328:13): [True: 31.1M, False: 5.13M]
  ------------------
  329|    926|      case kEof:
  ------------------
  |  Branch (329:7): [True: 926, False: 36.2M]
  ------------------
  330|    926|        return BareToken(TokenType::Eof);
  331|       |
  332|  3.51M|      case '\n':
  ------------------
  |  Branch (332:7): [True: 3.51M, False: 32.7M]
  ------------------
  333|  3.51M|        token_start_ = cursor_ - 1;
  334|  3.51M|        ERROR("newline in string");
  ------------------
  |  |   26|  3.51M|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  335|  3.51M|        has_error = true;
  336|  3.51M|        Newline();
  337|  3.51M|        continue;
  338|       |
  339|  1.37M|      case '"':
  ------------------
  |  Branch (339:7): [True: 1.37M, False: 34.8M]
  ------------------
  340|  1.37M|        if (PeekChar() == '"') {
  ------------------
  |  Branch (340:13): [True: 636k, False: 741k]
  ------------------
  341|   636k|          ERROR("invalid string token");
  ------------------
  |  |   26|   636k|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  342|   636k|          has_error = true;
  343|   636k|        }
  344|  1.37M|        in_string = false;
  345|  1.37M|        break;
  346|       |
  347|   237k|      case '\\': {
  ------------------
  |  Branch (347:7): [True: 237k, False: 36.0M]
  ------------------
  348|   237k|        switch (ReadChar()) {
  349|  1.02k|          case 't':
  ------------------
  |  Branch (349:11): [True: 1.02k, False: 236k]
  ------------------
  350|  2.94k|          case 'n':
  ------------------
  |  Branch (350:11): [True: 1.92k, False: 235k]
  ------------------
  351|  3.92k|          case 'r':
  ------------------
  |  Branch (351:11): [True: 975, False: 236k]
  ------------------
  352|  5.34k|          case '"':
  ------------------
  |  Branch (352:11): [True: 1.42k, False: 236k]
  ------------------
  353|  6.31k|          case '\'':
  ------------------
  |  Branch (353:11): [True: 970, False: 236k]
  ------------------
  354|  9.88k|          case '\\':
  ------------------
  |  Branch (354:11): [True: 3.56k, False: 234k]
  ------------------
  355|       |            // Valid escape.
  356|  9.88k|            break;
  357|       |
  358|    380|          case '0':
  ------------------
  |  Branch (358:11): [True: 380, False: 237k]
  ------------------
  359|    659|          case '1':
  ------------------
  |  Branch (359:11): [True: 279, False: 237k]
  ------------------
  360|  1.17k|          case '2':
  ------------------
  |  Branch (360:11): [True: 515, False: 237k]
  ------------------
  361|  1.71k|          case '3':
  ------------------
  |  Branch (361:11): [True: 539, False: 237k]
  ------------------
  362|  2.05k|          case '4':
  ------------------
  |  Branch (362:11): [True: 343, False: 237k]
  ------------------
  363|  2.45k|          case '5':
  ------------------
  |  Branch (363:11): [True: 396, False: 237k]
  ------------------
  364|  5.94k|          case '6':
  ------------------
  |  Branch (364:11): [True: 3.49k, False: 234k]
  ------------------
  365|  6.59k|          case '7':
  ------------------
  |  Branch (365:11): [True: 649, False: 237k]
  ------------------
  366|  7.00k|          case '8':
  ------------------
  |  Branch (366:11): [True: 405, False: 237k]
  ------------------
  367|  7.22k|          case '9':
  ------------------
  |  Branch (367:11): [True: 224, False: 237k]
  ------------------
  368|  14.3k|          case 'a':
  ------------------
  |  Branch (368:11): [True: 7.16k, False: 230k]
  ------------------
  369|  20.9k|          case 'b':
  ------------------
  |  Branch (369:11): [True: 6.57k, False: 231k]
  ------------------
  370|  21.5k|          case 'c':
  ------------------
  |  Branch (370:11): [True: 586, False: 237k]
  ------------------
  371|  21.8k|          case 'd':
  ------------------
  |  Branch (371:11): [True: 302, False: 237k]
  ------------------
  372|  22.0k|          case 'e':
  ------------------
  |  Branch (372:11): [True: 203, False: 237k]
  ------------------
  373|  22.3k|          case 'f':
  ------------------
  |  Branch (373:11): [True: 275, False: 237k]
  ------------------
  374|  22.5k|          case 'A':
  ------------------
  |  Branch (374:11): [True: 199, False: 237k]
  ------------------
  375|  23.9k|          case 'B':
  ------------------
  |  Branch (375:11): [True: 1.45k, False: 236k]
  ------------------
  376|  24.2k|          case 'C':
  ------------------
  |  Branch (376:11): [True: 215, False: 237k]
  ------------------
  377|  24.7k|          case 'D':
  ------------------
  |  Branch (377:11): [True: 556, False: 237k]
  ------------------
  378|  25.2k|          case 'E':
  ------------------
  |  Branch (378:11): [True: 489, False: 237k]
  ------------------
  379|  26.7k|          case 'F':  // Hex byte escape.
  ------------------
  |  Branch (379:11): [True: 1.52k, False: 236k]
  ------------------
  380|  26.7k|            if (IsHexDigit(PeekChar())) {
  ------------------
  |  Branch (380:17): [True: 6.04k, False: 20.7k]
  ------------------
  381|  6.04k|              ReadChar();
  382|  20.7k|            } else {
  383|  20.7k|              token_start_ = cursor_ - 2;
  384|  20.7k|              goto error;
  385|  20.7k|            }
  386|  6.04k|            break;
  387|       |
  388|  77.5k|          case 'u': {
  ------------------
  |  Branch (388:11): [True: 77.5k, False: 160k]
  ------------------
  389|  77.5k|            token_start_ = cursor_ - 2;
  390|  77.5k|            if (ReadChar() != '{') {
  ------------------
  |  Branch (390:17): [True: 364, False: 77.1k]
  ------------------
  391|    364|              goto error;
  392|    364|            }
  393|       |
  394|       |            // Value must be a valid unicode scalar value.
  395|  77.1k|            uint32_t digit;
  396|  77.1k|            uint32_t scalar_value = 0;
  397|       |
  398|   408k|            while (IsHexDigit(PeekChar())) {
  ------------------
  |  Branch (398:20): [True: 333k, False: 74.9k]
  ------------------
  399|   333k|              ParseHexdigit(*cursor_++, &digit);
  400|       |
  401|   333k|              scalar_value = (scalar_value << 4) | digit;
  402|       |              // Maximum value of a unicode code point.
  403|   333k|              if (scalar_value >= 0x110000) {
  ------------------
  |  Branch (403:19): [True: 2.25k, False: 331k]
  ------------------
  404|  2.25k|                goto error;
  405|  2.25k|              }
  406|   333k|            }
  407|       |
  408|  74.9k|            if (PeekChar() != '}') {
  ------------------
  |  Branch (408:17): [True: 2.16k, False: 72.7k]
  ------------------
  409|  2.16k|              goto error;
  410|  2.16k|            }
  411|       |
  412|       |            // Scalars between 0xd800 and 0xdfff are not allowed.
  413|  72.7k|            if ((scalar_value >= 0xd800 && scalar_value < 0xe000) ||
  ------------------
  |  Branch (413:18): [True: 67.1k, False: 5.58k]
  |  Branch (413:44): [True: 65.2k, False: 1.89k]
  ------------------
  414|  72.7k|                token_start_ == cursor_ - 3) {
  ------------------
  |  Branch (414:17): [True: 265, False: 7.21k]
  ------------------
  415|  65.5k|              ReadChar();
  416|  65.5k|              goto error;
  417|  65.5k|            }
  418|  7.21k|            break;
  419|  72.7k|          }
  420|       |
  421|   123k|          default:
  ------------------
  |  Branch (421:11): [True: 123k, False: 114k]
  ------------------
  422|   123k|            token_start_ = cursor_ - 2;
  423|   123k|            goto error;
  424|       |
  425|   214k|          error:
  426|   214k|            ERROR("bad escape \"%.*s\"",
  ------------------
  |  |   26|   214k|#define ERROR(...) Error(GetLocation(), __VA_ARGS__)
  ------------------
  427|   214k|                  static_cast<int>(cursor_ - token_start_), token_start_);
  428|   214k|            has_error = true;
  429|   214k|            break;
  430|   237k|        }
  431|   237k|        break;
  432|   237k|      }
  433|  36.2M|    }
  434|  36.2M|  }
  435|  1.37M|  token_start_ = saved_token_start;
  436|  1.37M|  if (has_error) {
  ------------------
  |  Branch (436:7): [True: 636k, False: 740k]
  ------------------
  437|   636k|    return Token(GetLocation(), TokenType::Invalid);
  438|   636k|  }
  439|       |
  440|   740k|  return TextToken(TokenType::Text);
  441|  1.37M|}
_ZN4wabt9WastLexer11IsCharClassEiNS0_9CharClassE:
  444|   231M|bool WastLexer::IsCharClass(int c, CharClass bit) {
  445|       |  // Generated by the following python script:
  446|       |  //
  447|       |  //   def Range(c, lo, hi): return lo <= c <= hi
  448|       |  //   def IsDigit(c): return Range(c, '0', '9')
  449|       |  //   def IsHexDigit(c): return IsDigit(c) or Range(c.lower(), 'a', 'f')
  450|       |  //   def IsKeyword(c): return Range(c, 'a', 'z')
  451|       |  //   def IsIdChar(c): return Range(c, '!', '~') and c not in '"(),;[]{}'
  452|       |  //
  453|       |  //   print ([0] + [
  454|       |  //       (8 if IsDigit(c) else 0) |
  455|       |  //       (4 if IsHexDigit(c) else 0) |
  456|       |  //       (2 if IsKeyword(c) else 0) |
  457|       |  //       (1 if IsIdChar(c) else 0)
  458|       |  //       for c in map(chr, range(0, 127))
  459|       |  //   ])
  460|   231M|  static const char kCharClasses[257] = {
  461|   231M|      0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,
  462|   231M|      0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  1,  0,  1,  1,
  463|   231M|      1,  1,  1, 0, 0, 1, 1, 0, 1, 1, 1, 13, 13, 13, 13, 13, 13, 13, 13,
  464|   231M|      13, 13, 1, 0, 1, 1, 1, 1, 1, 5, 5, 5,  5,  5,  5,  1,  1,  1,  1,
  465|   231M|      1,  1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,  1,  1,  0,  1,  0,
  466|   231M|      1,  1,  1, 7, 7, 7, 7, 7, 7, 3, 3, 3,  3,  3,  3,  3,  3,  3,  3,
  467|   231M|      3,  3,  3, 3, 3, 3, 3, 3, 3, 3, 0, 1,  0,  1,
  468|   231M|  };
  469|       |
  470|   231M|  assert(c >= -1 && c < 256);
  471|   231M|  return (kCharClasses[c + 1] & static_cast<int>(bit)) != 0;
  472|   231M|}
_ZN4wabt9WastLexer7ReadNumEv:
  474|  13.6M|bool WastLexer::ReadNum() {
  475|  13.6M|  if (IsDigit(PeekChar())) {
  ------------------
  |  Branch (475:7): [True: 13.5M, False: 20.0k]
  ------------------
  476|  13.5M|    ReadChar();
  477|  13.5M|    return MatchChar('_') || IsDigit(PeekChar()) ? ReadNum() : true;
  ------------------
  |  Branch (477:12): [True: 50.0k, False: 13.5M]
  |  Branch (477:30): [True: 11.9M, False: 1.57M]
  ------------------
  478|  13.5M|  }
  479|  20.0k|  return false;
  480|  13.6M|}
_ZN4wabt9WastLexer10ReadHexNumEv:
  482|  6.20M|bool WastLexer::ReadHexNum() {
  483|  6.20M|  if (IsHexDigit(PeekChar())) {
  ------------------
  |  Branch (483:7): [True: 6.20M, False: 5.55k]
  ------------------
  484|  6.20M|    ReadChar();
  485|  6.20M|    return MatchChar('_') || IsHexDigit(PeekChar()) ? ReadHexNum() : true;
  ------------------
  |  Branch (485:12): [True: 102k, False: 6.09M]
  |  Branch (485:30): [True: 5.71M, False: 378k]
  ------------------
  486|  6.20M|  }
  487|  5.55k|  return false;
  488|  6.20M|}
_ZN4wabt9WastLexer17ReadReservedCharsEv:
  490|  14.3M|WastLexer::ReservedChars WastLexer::ReadReservedChars() {
  491|  14.3M|  ReservedChars ret{ReservedChars::None};
  492|   151M|  while (true) {
  ------------------
  |  Branch (492:10): [Folded - Ignored]
  ------------------
  493|   151M|    auto peek = PeekChar();
  494|   151M|    if (IsIdChar(peek)) {
  ------------------
  |  Branch (494:9): [True: 136M, False: 15.1M]
  ------------------
  495|   136M|      ReadChar();
  496|   136M|      if (ret == ReservedChars::None) {
  ------------------
  |  Branch (496:11): [True: 11.5M, False: 124M]
  ------------------
  497|  11.5M|        ret = ReservedChars::Id;
  498|  11.5M|      }
  499|   136M|    } else if (peek == '"') {
  ------------------
  |  Branch (499:16): [True: 736k, False: 14.3M]
  ------------------
  500|   736k|      GetStringToken();
  501|   736k|      ret = ReservedChars::Some;
  502|  14.3M|    } else {
  503|  14.3M|      break;
  504|  14.3M|    }
  505|   151M|  }
  506|  14.3M|  return ret;
  507|  14.3M|}
_ZN4wabt9WastLexer8ReadSignEv:
  509|   130k|void WastLexer::ReadSign() {
  510|   130k|  if (PeekChar() == '+' || PeekChar() == '-') {
  ------------------
  |  Branch (510:7): [True: 917, False: 129k]
  |  Branch (510:28): [True: 97.6k, False: 31.5k]
  ------------------
  511|  98.6k|    ReadChar();
  512|  98.6k|  }
  513|   130k|}
_ZN4wabt9WastLexer14GetNumberTokenENS_9TokenTypeE:
  515|  1.35M|Token WastLexer::GetNumberToken(TokenType token_type) {
  516|  1.35M|  if (ReadNum()) {
  ------------------
  |  Branch (516:7): [True: 1.34M, False: 1.96k]
  ------------------
  517|  1.34M|    if (MatchChar('.')) {
  ------------------
  |  Branch (517:9): [True: 121k, False: 1.22M]
  ------------------
  518|   121k|      token_type = TokenType::Float;
  519|   121k|      if (IsDigit(PeekChar()) && !ReadNum()) {
  ------------------
  |  Branch (519:11): [True: 100k, False: 20.6k]
  |  Branch (519:34): [True: 345, False: 100k]
  ------------------
  520|    345|        return GetReservedToken();
  521|    345|      }
  522|   121k|    }
  523|  1.34M|    if (MatchChar('e') || MatchChar('E')) {
  ------------------
  |  Branch (523:9): [True: 1.75k, False: 1.34M]
  |  Branch (523:27): [True: 22.2k, False: 1.32M]
  ------------------
  524|  23.9k|      token_type = TokenType::Float;
  525|  23.9k|      ReadSign();
  526|  23.9k|      if (!ReadNum()) {
  ------------------
  |  Branch (526:11): [True: 3.72k, False: 20.2k]
  ------------------
  527|  3.72k|        return GetReservedToken();
  528|  3.72k|      }
  529|  23.9k|    }
  530|  1.34M|    if (NoTrailingReservedChars()) {
  ------------------
  |  Branch (530:9): [True: 1.22M, False: 119k]
  ------------------
  531|  1.22M|      if (token_type == TokenType::Float) {
  ------------------
  |  Branch (531:11): [True: 118k, False: 1.10M]
  ------------------
  532|   118k|        return LiteralToken(token_type, LiteralType::Float);
  533|  1.10M|      } else {
  534|  1.10M|        return LiteralToken(token_type, LiteralType::Int);
  535|  1.10M|      }
  536|  1.22M|    }
  537|  1.34M|  }
  538|   121k|  return GetReservedToken();
  539|  1.35M|}
_ZN4wabt9WastLexer17GetHexNumberTokenENS_9TokenTypeE:
  541|   274k|Token WastLexer::GetHexNumberToken(TokenType token_type) {
  542|   274k|  if (ReadHexNum()) {
  ------------------
  |  Branch (542:7): [True: 270k, False: 3.77k]
  ------------------
  543|   270k|    if (MatchChar('.')) {
  ------------------
  |  Branch (543:9): [True: 94.5k, False: 176k]
  ------------------
  544|  94.5k|      token_type = TokenType::Float;
  545|  94.5k|      if (IsHexDigit(PeekChar()) && !ReadHexNum()) {
  ------------------
  |  Branch (545:11): [True: 82.3k, False: 12.2k]
  |  Branch (545:37): [True: 194, False: 82.1k]
  ------------------
  546|    194|        return GetReservedToken();
  547|    194|      }
  548|  94.5k|    }
  549|   270k|    if (MatchChar('p') || MatchChar('P')) {
  ------------------
  |  Branch (549:9): [True: 89.9k, False: 180k]
  |  Branch (549:27): [True: 16.1k, False: 164k]
  ------------------
  550|   106k|      token_type = TokenType::Float;
  551|   106k|      ReadSign();
  552|   106k|      if (!ReadNum()) {
  ------------------
  |  Branch (552:11): [True: 13.3k, False: 92.7k]
  ------------------
  553|  13.3k|        return GetReservedToken();
  554|  13.3k|      }
  555|   106k|    }
  556|   257k|    if (NoTrailingReservedChars()) {
  ------------------
  |  Branch (556:9): [True: 227k, False: 29.8k]
  ------------------
  557|   227k|      if (token_type == TokenType::Float) {
  ------------------
  |  Branch (557:11): [True: 169k, False: 57.4k]
  ------------------
  558|   169k|        return LiteralToken(token_type, LiteralType::Hexfloat);
  559|   169k|      } else {
  560|  57.4k|        return LiteralToken(token_type, LiteralType::Int);
  561|  57.4k|      }
  562|   227k|    }
  563|   257k|  }
  564|  33.5k|  return GetReservedToken();
  565|   274k|}
_ZN4wabt9WastLexer11GetInfTokenEv:
  567|  1.39M|Token WastLexer::GetInfToken() {
  568|  1.39M|  if (MatchString("inf")) {
  ------------------
  |  Branch (568:7): [True: 64.3k, False: 1.32M]
  ------------------
  569|  64.3k|    if (NoTrailingReservedChars()) {
  ------------------
  |  Branch (569:9): [True: 63.1k, False: 1.20k]
  ------------------
  570|  63.1k|      return LiteralToken(TokenType::Float, LiteralType::Infinity);
  571|  63.1k|    }
  572|  1.20k|    return GetReservedToken();
  573|  64.3k|  }
  574|  1.32M|  return GetKeywordToken();
  575|  1.39M|}
_ZN4wabt9WastLexer11GetNanTokenEv:
  577|   277k|Token WastLexer::GetNanToken() {
  578|   277k|  if (MatchString("nan")) {
  ------------------
  |  Branch (578:7): [True: 37.9k, False: 239k]
  ------------------
  579|  37.9k|    if (MatchChar(':')) {
  ------------------
  |  Branch (579:9): [True: 18.8k, False: 19.0k]
  ------------------
  580|  18.8k|      if (MatchString("0x") && ReadHexNum() && NoTrailingReservedChars()) {
  ------------------
  |  Branch (580:11): [True: 16.2k, False: 2.63k]
  |  Branch (580:32): [True: 15.6k, False: 577]
  |  Branch (580:48): [True: 14.9k, False: 737]
  ------------------
  581|  14.9k|        return LiteralToken(TokenType::Float, LiteralType::Nan);
  582|  14.9k|      }
  583|  19.0k|    } else if (NoTrailingReservedChars()) {
  ------------------
  |  Branch (583:16): [True: 18.2k, False: 809]
  ------------------
  584|  18.2k|      return LiteralToken(TokenType::Float, LiteralType::Nan);
  585|  18.2k|    }
  586|  37.9k|  }
  587|   244k|  return GetKeywordToken();
  588|   277k|}
_ZN4wabt9WastLexer17GetNameEqNumTokenENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9TokenTypeE:
  591|  95.3k|                                   TokenType token_type) {
  592|  95.3k|  if (MatchString(name)) {
  ------------------
  |  Branch (592:7): [True: 21.8k, False: 73.4k]
  ------------------
  593|  21.8k|    if (MatchString("0x")) {
  ------------------
  |  Branch (593:9): [True: 11.3k, False: 10.5k]
  ------------------
  594|  11.3k|      if (ReadHexNum() && NoTrailingReservedChars()) {
  ------------------
  |  Branch (594:11): [True: 10.3k, False: 1.01k]
  |  Branch (594:27): [True: 9.07k, False: 1.23k]
  ------------------
  595|  9.07k|        return TextToken(token_type, name.size());
  596|  9.07k|      }
  597|  11.3k|    } else if (ReadNum() && NoTrailingReservedChars()) {
  ------------------
  |  Branch (597:16): [True: 9.94k, False: 590]
  |  Branch (597:29): [True: 6.48k, False: 3.46k]
  ------------------
  598|  6.48k|      return TextToken(token_type, name.size());
  599|  6.48k|    }
  600|  21.8k|  }
  601|  79.7k|  return GetKeywordToken();
  602|  95.3k|}
_ZN4wabt9WastLexer10GetIdCharsEv:
  604|  3.70M|Token WastLexer::GetIdChars() {
  605|  3.70M|  if (ReadReservedChars() == ReservedChars::Id) {
  ------------------
  |  Branch (605:7): [True: 2.65M, False: 1.04M]
  ------------------
  606|  2.65M|    return TextToken(TokenType::Var);
  607|  2.65M|  }
  608|       |
  609|  1.04M|  return TextToken(TokenType::Reserved);
  610|  3.70M|}
_ZN4wabt9WastLexer15GetKeywordTokenEv:
  612|  8.39M|Token WastLexer::GetKeywordToken() {
  613|  8.39M|  ReadReservedChars();
  614|  8.39M|  TokenInfo* info =
  615|  8.39M|      Perfect_Hash::InWordSet(token_start_, cursor_ - token_start_);
  616|  8.39M|  if (!info) {
  ------------------
  |  Branch (616:7): [True: 1.56M, False: 6.82M]
  ------------------
  617|  1.56M|    return TextToken(TokenType::Reserved);
  618|  1.56M|  }
  619|  6.82M|  if (IsTokenTypeBare(info->token_type)) {
  ------------------
  |  Branch (619:7): [True: 2.66M, False: 4.16M]
  ------------------
  620|  2.66M|    return BareToken(info->token_type);
  621|  4.16M|  } else if (IsTokenTypeType(info->token_type) ||
  ------------------
  |  Branch (621:14): [True: 666k, False: 3.49M]
  ------------------
  622|  4.16M|             IsTokenTypeRefKind(info->token_type)) {
  ------------------
  |  Branch (622:14): [True: 2.25M, False: 1.24M]
  ------------------
  623|  2.91M|    return Token(GetLocation(), info->token_type, info->value_type);
  624|  2.91M|  } else {
  625|  1.24M|    assert(IsTokenTypeOpcode(info->token_type));
  626|  1.24M|    return Token(GetLocation(), info->token_type, info->opcode);
  627|  1.24M|  }
  628|  6.82M|}
_ZN4wabt9WastLexer16GetReservedTokenEv:
  630|   575k|Token WastLexer::GetReservedToken() {
  631|   575k|  ReadReservedChars();
  632|   575k|  return TextToken(TokenType::Reserved);
  633|   575k|}
_ZN4wabt9WastLexer5ErrorENS_8LocationEPKcz:
  635|  21.2M|void WastLexer::Error(Location loc, const char* format, ...) {
  636|  21.2M|  WABT_SNPRINTF_ALLOCA(buffer, length, format);
  ------------------
  |  |   36|  21.2M|  va_list args;                                                            \
  |  |   37|  21.2M|  va_list args_copy;                                                       \
  |  |   38|  21.2M|  va_start(args, format);                                                  \
  |  |   39|  21.2M|  va_copy(args_copy, args);                                                \
  |  |   40|  21.2M|  char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE];                    \
  |  |   41|  21.2M|  char* buffer = fixed_buf;                                                \
  |  |   42|  21.2M|  size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \
  |  |  ------------------
  |  |  |  |  288|  21.2M|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   43|  21.2M|  va_end(args);                                                            \
  |  |   44|  21.2M|  if (len + 1 > sizeof(fixed_buf)) {                                       \
  |  |  ------------------
  |  |  |  Branch (44:7): [True: 201, False: 21.2M]
  |  |  ------------------
  |  |   45|    201|    buffer = static_cast<char*>(alloca(len + 1));                          \
  |  |   46|    201|    len = wabt_vsnprintf(buffer, len + 1, format, args_copy);              \
  |  |  ------------------
  |  |  |  |  288|    201|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   47|    201|  }                                                                        \
  |  |   48|  21.2M|  va_end(args_copy)
  ------------------
  637|  21.2M|  errors_->emplace_back(ErrorLevel::Error, loc, buffer);
  638|  21.2M|}
wast-lexer.cc:_ZZN4wabt9WastLexer11GetLocationEvENK3$_0clEPKc:
  190|  97.3M|  auto column = [this](const char* p) {
  191|  97.3M|    return std::max(1, static_cast<int>(p - line_start_ + 1));
  192|  97.3M|  };

_ZN4wabt10WastParserC2EPNS_9WastLexerEPNSt3__16vectorINS_5ErrorENS3_9allocatorIS5_EEEEPNS_16WastParseOptionsE:
  555|  23.2k|    : lexer_(lexer), errors_(errors), options_(options) {}
_ZN4wabt10WastParser5ErrorENS_8LocationEPKcz:
  557|  6.20M|void WastParser::Error(Location loc, const char* format, ...) {
  558|  6.20M|  WABT_SNPRINTF_ALLOCA(buffer, length, format);
  ------------------
  |  |   36|  6.20M|  va_list args;                                                            \
  |  |   37|  6.20M|  va_list args_copy;                                                       \
  |  |   38|  6.20M|  va_start(args, format);                                                  \
  |  |   39|  6.20M|  va_copy(args_copy, args);                                                \
  |  |   40|  6.20M|  char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE];                    \
  |  |   41|  6.20M|  char* buffer = fixed_buf;                                                \
  |  |   42|  6.20M|  size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \
  |  |  ------------------
  |  |  |  |  288|  6.20M|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   43|  6.20M|  va_end(args);                                                            \
  |  |   44|  6.20M|  if (len + 1 > sizeof(fixed_buf)) {                                       \
  |  |  ------------------
  |  |  |  Branch (44:7): [True: 6.30k, False: 6.20M]
  |  |  ------------------
  |  |   45|  6.30k|    buffer = static_cast<char*>(alloca(len + 1));                          \
  |  |   46|  6.30k|    len = wabt_vsnprintf(buffer, len + 1, format, args_copy);              \
  |  |  ------------------
  |  |  |  |  288|  6.30k|#define wabt_vsnprintf vsnprintf
  |  |  ------------------
  |  |   47|  6.30k|  }                                                                        \
  |  |   48|  6.20M|  va_end(args_copy)
  ------------------
  559|  6.20M|  errors_->emplace_back(ErrorLevel::Error, loc, buffer);
  560|  6.20M|}
_ZN4wabt10WastParser8GetTokenEv:
  562|  9.37M|Token WastParser::GetToken() {
  563|  9.37M|  if (tokens_.empty()) {
  ------------------
  |  Branch (563:7): [True: 991k, False: 8.38M]
  ------------------
  564|   991k|    tokens_.push_back(lexer_->GetToken());
  565|   991k|  }
  566|  9.37M|  return tokens_.front();
  567|  9.37M|}
_ZN4wabt10WastParser11GetLocationEv:
  569|  8.31M|Location WastParser::GetLocation() {
  570|  8.31M|  return GetToken().loc;
  571|  8.31M|}
_ZN4wabt10WastParser4PeekEm:
  573|  91.4M|TokenType WastParser::Peek(size_t n) {
  574|  91.4M|  assert(n <= 1);
  575|   116M|  while (tokens_.size() <= n) {
  ------------------
  |  Branch (575:10): [True: 24.5M, False: 91.4M]
  ------------------
  576|  24.5M|    Token cur = lexer_->GetToken();
  577|  24.5M|    if (cur.token_type() != TokenType::LparAnn) {
  ------------------
  |  Branch (577:9): [True: 23.4M, False: 1.09M]
  ------------------
  578|  23.4M|      tokens_.push_back(cur);
  579|  23.4M|    } else {
  580|       |      // Custom annotation. For now, discard until matching Rpar, unless it is
  581|       |      // a code metadata annotation or custom section. In those cases, we know
  582|       |      // how to parse it.
  583|  1.09M|      if (!options_->features.annotations_enabled()) {
  ------------------
  |  Branch (583:11): [True: 1.09M, False: 0]
  ------------------
  584|  1.09M|        Error(cur.loc, "annotations not enabled: %s", cur.to_string().c_str());
  585|  1.09M|        tokens_.push_back(Token(cur.loc, TokenType::Invalid));
  586|  1.09M|        continue;
  587|  1.09M|      }
  588|      0|      if ((options_->features.code_metadata_enabled() &&
  ------------------
  |  Branch (588:11): [True: 0, False: 0]
  |  Branch (588:12): [True: 0, False: 0]
  ------------------
  589|      0|           cur.text().find("metadata.code.") == 0) ||
  ------------------
  |  Branch (589:12): [True: 0, False: 0]
  ------------------
  590|      0|          cur.text() == "custom") {
  ------------------
  |  Branch (590:11): [True: 0, False: 0]
  ------------------
  591|      0|        tokens_.push_back(cur);
  592|      0|        continue;
  593|      0|      }
  594|      0|      int indent = 1;
  595|      0|      while (indent > 0) {
  ------------------
  |  Branch (595:14): [True: 0, False: 0]
  ------------------
  596|      0|        cur = lexer_->GetToken();
  597|      0|        switch (cur.token_type()) {
  598|      0|          case TokenType::Lpar:
  ------------------
  |  Branch (598:11): [True: 0, False: 0]
  ------------------
  599|      0|          case TokenType::LparAnn:
  ------------------
  |  Branch (599:11): [True: 0, False: 0]
  ------------------
  600|      0|            indent++;
  601|      0|            break;
  602|       |
  603|      0|          case TokenType::Rpar:
  ------------------
  |  Branch (603:11): [True: 0, False: 0]
  ------------------
  604|      0|            indent--;
  605|      0|            break;
  606|       |
  607|      0|          case TokenType::Eof:
  ------------------
  |  Branch (607:11): [True: 0, False: 0]
  ------------------
  608|      0|            indent = 0;
  609|      0|            Error(cur.loc, "unterminated annotation");
  610|      0|            break;
  611|       |
  612|      0|          default:
  ------------------
  |  Branch (612:11): [True: 0, False: 0]
  ------------------
  613|      0|            break;
  614|      0|        }
  615|      0|      }
  616|      0|    }
  617|  24.5M|  }
  618|  91.4M|  return tokens_.at(n).token_type();
  619|  91.4M|}
_ZN4wabt10WastParser8PeekPairEv:
  621|  17.1M|TokenTypePair WastParser::PeekPair() {
  622|  17.1M|  return TokenTypePair{{Peek(), Peek(1)}};
  623|  17.1M|}
_ZN4wabt10WastParser9PeekMatchENS_9TokenTypeEm:
  625|  30.4M|bool WastParser::PeekMatch(TokenType type, size_t n) {
  626|  30.4M|  return Peek(n) == type;
  627|  30.4M|}
_ZN4wabt10WastParser13PeekMatchLparENS_9TokenTypeE:
  629|  17.5M|bool WastParser::PeekMatchLpar(TokenType type) {
  630|  17.5M|  return Peek() == TokenType::Lpar && Peek(1) == type;
  ------------------
  |  Branch (630:10): [True: 2.38M, False: 15.1M]
  |  Branch (630:39): [True: 388k, False: 2.00M]
  ------------------
  631|  17.5M|}
_ZN4wabt10WastParser13PeekMatchExprEv:
  633|  1.41M|bool WastParser::PeekMatchExpr() {
  634|  1.41M|  return IsExpr(PeekPair());
  635|  1.41M|}
_ZN4wabt10WastParser16PeekMatchRefTypeEv:
  637|   603k|bool WastParser::PeekMatchRefType() {
  638|   603k|  return (options_->features.function_references_enabled() ||
  ------------------
  |  Branch (638:11): [True: 0, False: 603k]
  ------------------
  639|   603k|          options_->features.exceptions_enabled()) &&
  ------------------
  |  Branch (639:11): [True: 0, False: 603k]
  ------------------
  640|   603k|         PeekMatchLpar(TokenType::Ref);
  ------------------
  |  Branch (640:10): [True: 0, False: 0]
  ------------------
  641|   603k|}
_ZN4wabt10WastParser5MatchENS_9TokenTypeE:
  643|  16.3M|bool WastParser::Match(TokenType type) {
  644|  16.3M|  if (PeekMatch(type)) {
  ------------------
  |  Branch (644:7): [True: 10.1M, False: 6.18M]
  ------------------
  645|  10.1M|    Consume();
  646|  10.1M|    return true;
  647|  10.1M|  }
  648|  6.18M|  return false;
  649|  16.3M|}
_ZN4wabt10WastParser9MatchLparENS_9TokenTypeE:
  651|  9.86M|bool WastParser::MatchLpar(TokenType type) {
  652|  9.86M|  if (PeekMatchLpar(type)) {
  ------------------
  |  Branch (652:7): [True: 97.6k, False: 9.76M]
  ------------------
  653|  97.6k|    Consume();
  654|  97.6k|    Consume();
  655|  97.6k|    return true;
  656|  97.6k|  }
  657|  9.76M|  return false;
  658|  9.86M|}
_ZN4wabt10WastParser6ExpectENS_9TokenTypeE:
  660|  12.4M|Result WastParser::Expect(TokenType type) {
  661|  12.4M|  if (!Match(type)) {
  ------------------
  |  Branch (661:7): [True: 2.62M, False: 9.83M]
  ------------------
  662|  2.62M|    Token token = Consume();
  663|  2.62M|    Error(token.loc, "unexpected token %s, expected %s.",
  664|  2.62M|          token.to_string_clamp(kMaxErrorTokenLength).c_str(),
  665|  2.62M|          GetTokenTypeName(type));
  666|  2.62M|    return Result::Error;
  667|  2.62M|  }
  668|       |
  669|  9.83M|  return Result::Ok;
  670|  12.4M|}
_ZN4wabt10WastParser7ConsumeEv:
  672|  25.5M|Token WastParser::Consume() {
  673|  25.5M|  assert(!tokens_.empty());
  674|  25.5M|  Token token = tokens_.front();
  675|  25.5M|  tokens_.pop_front();
  676|  25.5M|  return token;
  677|  25.5M|}
_ZN4wabt10WastParser11SynchronizeEPFbNSt3__15arrayINS_9TokenTypeELm2EEEE:
  679|  3.51M|Result WastParser::Synchronize(SynchronizeFunc func) {
  680|  3.51M|  static const int kMaxConsumed = 10;
  681|  9.39M|  for (int i = 0; i < kMaxConsumed; ++i) {
  ------------------
  |  Branch (681:19): [True: 9.13M, False: 255k]
  ------------------
  682|  9.13M|    if (func(PeekPair())) {
  ------------------
  |  Branch (682:9): [True: 3.26M, False: 5.87M]
  ------------------
  683|  3.26M|      return Result::Ok;
  684|  3.26M|    }
  685|       |
  686|  5.87M|    Token token = Consume();
  687|  5.87M|    if (token.token_type() == TokenType::Reserved) {
  ------------------
  |  Branch (687:9): [True: 1.33M, False: 4.54M]
  ------------------
  688|  1.33M|      Error(token.loc, "unexpected token %s.",
  689|  1.33M|            token.to_string_clamp(kMaxErrorTokenLength).c_str());
  690|  1.33M|    }
  691|  5.87M|  }
  692|       |
  693|   255k|  return Result::Error;
  694|  3.51M|}
_ZN4wabt10WastParser24ErrorUnlessOpcodeEnabledERKNS_5TokenE:
  696|   294k|void WastParser::ErrorUnlessOpcodeEnabled(const Token& token) {
  697|   294k|  Opcode opcode = token.opcode();
  698|   294k|  if (!opcode.IsEnabled(options_->features)) {
  ------------------
  |  Branch (698:7): [True: 152k, False: 141k]
  ------------------
  699|   152k|    Error(token.loc, "opcode not allowed: %s", opcode.GetName());
  700|   152k|  }
  701|   294k|}
_ZN4wabt10WastParser13ErrorExpectedERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEPKc:
  704|   605k|                                 const char* example) {
  705|   605k|  GetToken();
  706|   605k|  Token token = Consume();
  707|   605k|  std::string expected_str;
  708|   605k|  if (!expected.empty()) {
  ------------------
  |  Branch (708:7): [True: 605k, False: 0]
  ------------------
  709|   605k|    expected_str = ", expected ";
  710|  1.61M|    for (size_t i = 0; i < expected.size(); ++i) {
  ------------------
  |  Branch (710:24): [True: 1.00M, False: 605k]
  ------------------
  711|  1.00M|      if (i != 0) {
  ------------------
  |  Branch (711:11): [True: 400k, False: 605k]
  ------------------
  712|   400k|        if (i == expected.size() - 1) {
  ------------------
  |  Branch (712:13): [True: 96.4k, False: 304k]
  ------------------
  713|  96.4k|          expected_str += " or ";
  714|   304k|        } else {
  715|   304k|          expected_str += ", ";
  716|   304k|        }
  717|   400k|      }
  718|       |
  719|  1.00M|      expected_str += expected[i];
  720|  1.00M|    }
  721|       |
  722|   605k|    if (example) {
  ------------------
  |  Branch (722:9): [True: 319k, False: 285k]
  ------------------
  723|   319k|      expected_str += " (e.g. ";
  724|   319k|      expected_str += example;
  725|   319k|      expected_str += ")";
  726|   319k|    }
  727|   605k|  }
  728|       |
  729|   605k|  Error(token.loc, "unexpected token \"%s\"%s.",
  730|   605k|        token.to_string_clamp(kMaxErrorTokenLength).c_str(),
  731|   605k|        expected_str.c_str());
  732|   605k|  return Result::Error;
  733|   605k|}
_ZN4wabt10WastParser11ErrorIfLparERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEPKc:
  736|  2.74M|                               const char* example) {
  737|  2.74M|  if (Match(TokenType::Lpar)) {
  ------------------
  |  Branch (737:7): [True: 201k, False: 2.54M]
  ------------------
  738|   201k|    return ErrorExpected(expected, example);
  739|   201k|  }
  740|  2.54M|  return Result::Ok;
  741|  2.74M|}
_ZN4wabt10WastParser15ParseBindVarOptEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  743|  3.65M|bool WastParser::ParseBindVarOpt(std::string* name) {
  744|  3.65M|  WABT_TRACE(ParseBindVarOpt);
  745|  3.65M|  if (!PeekMatch(TokenType::Var)) {
  ------------------
  |  Branch (745:7): [True: 2.75M, False: 895k]
  ------------------
  746|  2.75M|    return false;
  747|  2.75M|  }
  748|   895k|  Token token = Consume();
  749|   895k|  *name = std::string(token.text());
  750|   895k|  return true;
  751|  3.65M|}
_ZN4wabt10WastParser8ParseVarEPNS_3VarE:
  753|   987k|Result WastParser::ParseVar(Var* out_var) {
  754|   987k|  WABT_TRACE(ParseVar);
  755|   987k|  if (PeekMatch(TokenType::Nat)) {
  ------------------
  |  Branch (755:7): [True: 79.8k, False: 907k]
  ------------------
  756|  79.8k|    Token token = Consume();
  757|  79.8k|    std::string_view sv = token.literal().text;
  758|  79.8k|    uint64_t index = kInvalidIndex;
  759|  79.8k|    if (Failed(ParseUint64(sv, &index))) {
  ------------------
  |  Branch (759:9): [True: 742, False: 79.0k]
  ------------------
  760|       |      // Print an error, but don't fail parsing.
  761|    742|      Error(token.loc, "invalid int \"" PRIstringview "\"",
  762|    742|            WABT_PRINTF_STRING_VIEW_ARG(sv));
  ------------------
  |  |   28|    742|  static_cast<int>((x).length()), (x).data()
  ------------------
  763|    742|    }
  764|       |
  765|  79.8k|    *out_var = Var(index, token.loc);
  766|  79.8k|    return Result::Ok;
  767|   907k|  } else if (PeekMatch(TokenType::Var)) {
  ------------------
  |  Branch (767:14): [True: 887k, False: 20.5k]
  ------------------
  768|   887k|    Token token = Consume();
  769|   887k|    *out_var = Var(token.text(), token.loc);
  770|   887k|    return Result::Ok;
  771|   887k|  } else {
  772|  20.5k|    return ErrorExpected({"a numeric index", "a name"}, "12 or $foo");
  773|  20.5k|  }
  774|   987k|}
_ZN4wabt10WastParser11ParseVarOptEPNS_3VarES1_:
  776|  1.49M|bool WastParser::ParseVarOpt(Var* out_var, Var default_var) {
  777|  1.49M|  WABT_TRACE(ParseVarOpt);
  778|  1.49M|  if (PeekMatch(TokenType::Nat) || PeekMatch(TokenType::Var)) {
  ------------------
  |  Branch (778:7): [True: 31.0k, False: 1.46M]
  |  Branch (778:36): [True: 821k, False: 645k]
  ------------------
  779|   852k|    Result result = ParseVar(out_var);
  780|       |    // Should always succeed, the only way it could fail is if the token
  781|       |    // doesn't match.
  782|   852k|    assert(Succeeded(result));
  783|   852k|    WABT_USE(result);
  ------------------
  |  |   44|   852k|#define WABT_USE(x) static_cast<void>(x)
  ------------------
  784|   852k|    return true;
  785|   852k|  } else {
  786|   645k|    *out_var = default_var;
  787|   645k|    return false;
  788|   645k|  }
  789|  1.49M|}
_ZN4wabt10WastParser15ParseOffsetExprEPNS_14intrusive_listINS_4ExprEEE:
  791|  3.62k|Result WastParser::ParseOffsetExpr(ExprList* out_expr_list) {
  792|  3.62k|  WABT_TRACE(ParseOffsetExpr);
  793|  3.62k|  if (!ParseOffsetExprOpt(out_expr_list)) {
  ------------------
  |  Branch (793:7): [True: 2.45k, False: 1.17k]
  ------------------
  794|  2.45k|    return ErrorExpected({"an offset expr"}, "(i32.const 123)");
  795|  2.45k|  }
  796|  1.17k|  return Result::Ok;
  797|  3.62k|}
_ZN4wabt10WastParser18ParseOffsetExprOptEPNS_14intrusive_listINS_4ExprEEE:
  799|   338k|bool WastParser::ParseOffsetExprOpt(ExprList* out_expr_list) {
  800|   338k|  WABT_TRACE(ParseOffsetExprOpt);
  801|   338k|  if (MatchLpar(TokenType::Offset)) {
  ------------------
  |  Branch (801:7): [True: 388, False: 338k]
  ------------------
  802|    388|    CHECK_RESULT(ParseTerminatingInstrList(out_expr_list));
  ------------------
  |  |   55|    388|  do {                              \
  |  |   56|    388|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 194, False: 194]
  |  |  ------------------
  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |   58|    194|    }                               \
  |  |   59|    388|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  803|    194|    EXPECT(Rpar);
  ------------------
  |  |   31|    194|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    194|  do {                              \
  |  |  |  |   56|    194|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 194, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |  |  |   58|    194|    }                               \
  |  |  |  |   59|    194|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  804|      0|    return true;
  805|   338k|  } else if (PeekMatchExpr()) {
  ------------------
  |  Branch (805:14): [True: 35.3k, False: 302k]
  ------------------
  806|  35.3k|    CHECK_RESULT(ParseExpr(out_expr_list));
  ------------------
  |  |   55|  35.3k|  do {                              \
  |  |   56|  35.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 34.8k, False: 546]
  |  |  ------------------
  |  |   57|  34.8k|      return ::wabt::Result::Error; \
  |  |   58|  34.8k|    }                               \
  |  |   59|  35.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  807|    546|    return true;
  808|   302k|  } else {
  809|   302k|    return false;
  810|   302k|  }
  811|   338k|}
_ZN4wabt10WastParser16ParseTextListOptEPNSt3__16vectorIhNS1_9allocatorIhEEEE:
  823|  76.3k|bool WastParser::ParseTextListOpt(std::vector<uint8_t>* out_data) {
  824|  76.3k|  WABT_TRACE(ParseTextListOpt);
  825|  76.3k|  TextVector texts;
  826|   115k|  while (PeekMatch(TokenType::Text))
  ------------------
  |  Branch (826:10): [True: 39.0k, False: 76.3k]
  ------------------
  827|  39.0k|    texts.push_back(Consume().text());
  828|       |
  829|  76.3k|  RemoveEscapes(texts, std::back_inserter(*out_data));
  830|  76.3k|  return !texts.empty();
  831|  76.3k|}
_ZN4wabt10WastParser12ParseVarListEPNSt3__16vectorINS_3VarENS1_9allocatorIS3_EEEE:
  833|  5.70k|Result WastParser::ParseVarList(VarVector* out_var_list) {
  834|  5.70k|  WABT_TRACE(ParseVarList);
  835|  5.70k|  Var var;
  836|   647k|  while (ParseVarOpt(&var)) {
  ------------------
  |  Branch (836:10): [True: 641k, False: 5.70k]
  ------------------
  837|   641k|    out_var_list->emplace_back(var);
  838|   641k|  }
  839|  5.70k|  if (out_var_list->empty()) {
  ------------------
  |  Branch (839:7): [True: 4.50k, False: 1.20k]
  ------------------
  840|  4.50k|    return ErrorExpected({"a var"}, "12 or $foo");
  841|  4.50k|  } else {
  842|  1.20k|    return Result::Ok;
  843|  1.20k|  }
  844|  5.70k|}
_ZN4wabt10WastParser16ParseElemExprOptEPNS_14intrusive_listINS_4ExprEEE:
  846|  4.83k|bool WastParser::ParseElemExprOpt(ExprList* out_elem_expr) {
  847|  4.83k|  WABT_TRACE(ParseElemExprOpt);
  848|  4.83k|  bool item = MatchLpar(TokenType::Item);
  849|  4.83k|  ExprList exprs;
  850|  4.83k|  if (item) {
  ------------------
  |  Branch (850:7): [True: 654, False: 4.18k]
  ------------------
  851|    654|    if (ParseTerminatingInstrList(&exprs) != Result::Ok) {
  ------------------
  |  Branch (851:9): [True: 194, False: 460]
  ------------------
  852|    194|      return false;
  853|    194|    }
  854|    460|    EXPECT(Rpar);
  ------------------
  |  |   31|    460|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    460|  do {                              \
  |  |  |  |   56|    460|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 263, False: 197]
  |  |  |  |  ------------------
  |  |  |  |   57|    263|      return ::wabt::Result::Error; \
  |  |  |  |   58|    263|    }                               \
  |  |  |  |   59|    460|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  855|  4.18k|  } else {
  856|  4.18k|    if (!IsExpr(PeekPair()) || ParseExpr(&exprs) != Result::Ok) {
  ------------------
  |  Branch (856:9): [True: 1.87k, False: 2.30k]
  |  Branch (856:9): [True: 2.14k, False: 2.03k]
  |  Branch (856:32): [True: 274, False: 2.03k]
  ------------------
  857|  2.14k|      return false;
  858|  2.14k|    }
  859|  4.18k|  }
  860|  2.22k|  if (!exprs.size()) {
  ------------------
  |  Branch (860:7): [True: 194, False: 2.03k]
  ------------------
  861|    194|    return false;
  862|    194|  }
  863|  2.03k|  *out_elem_expr = std::move(exprs);
  864|  2.03k|  return true;
  865|  2.22k|}
_ZN4wabt10WastParser20ParseElemExprListOptEPNSt3__16vectorINS_14intrusive_listINS_4ExprEEENS1_9allocatorIS5_EEEE:
  867|  1.94k|bool WastParser::ParseElemExprListOpt(ExprListVector* out_list) {
  868|  1.94k|  ExprList elem_expr;
  869|  3.83k|  while (ParseElemExprOpt(&elem_expr)) {
  ------------------
  |  Branch (869:10): [True: 1.88k, False: 1.94k]
  ------------------
  870|  1.88k|    out_list->push_back(std::move(elem_expr));
  871|  1.88k|  }
  872|  1.94k|  return !out_list->empty();
  873|  1.94k|}
_ZN4wabt10WastParser23ParseElemExprVarListOptEPNSt3__16vectorINS_14intrusive_listINS_4ExprEEENS1_9allocatorIS5_EEEE:
  875|   259k|bool WastParser::ParseElemExprVarListOpt(ExprListVector* out_list) {
  876|   259k|  WABT_TRACE(ParseElemExprVarListOpt);
  877|   259k|  Var var;
  878|   259k|  ExprList init_expr;
  879|   414k|  while (ParseVarOpt(&var)) {
  ------------------
  |  Branch (879:10): [True: 154k, False: 259k]
  ------------------
  880|   154k|    init_expr.push_back(std::make_unique<RefFuncExpr>(var));
  881|   154k|    out_list->push_back(std::move(init_expr));
  882|   154k|  }
  883|   259k|  return !out_list->empty();
  884|   259k|}
_ZN4wabt10WastParser14ParseValueTypeEPNS_3VarE:
  886|   529k|Result WastParser::ParseValueType(Var* out_type) {
  887|   529k|  WABT_TRACE(ParseValueType);
  888|       |
  889|   529k|  const bool is_ref_type = PeekMatchRefType();
  890|   529k|  const bool is_value_type = PeekMatch(TokenType::ValueType);
  891|       |
  892|   529k|  if (!is_value_type && !is_ref_type) {
  ------------------
  |  Branch (892:7): [True: 46.0k, False: 482k]
  |  Branch (892:25): [True: 46.0k, False: 0]
  ------------------
  893|  46.0k|    return ErrorExpected(
  894|  46.0k|        {"i32", "i64", "f32", "f64", "v128", "externref", "exnref", "funcref"});
  895|  46.0k|  }
  896|       |
  897|   482k|  if (is_ref_type) {
  ------------------
  |  Branch (897:7): [True: 0, False: 482k]
  ------------------
  898|      0|    EXPECT(Lpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  899|      0|    EXPECT(Ref);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  900|      0|    CHECK_RESULT(ParseVar(out_type));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  901|      0|    EXPECT(Rpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  902|      0|    return Result::Ok;
  903|      0|  }
  904|       |
  905|   482k|  Token token = Consume();
  906|   482k|  Type type = token.type();
  907|   482k|  bool is_enabled;
  908|   482k|  switch (type) {
  909|    196|    case Type::V128:
  ------------------
  |  Branch (909:5): [True: 196, False: 482k]
  ------------------
  910|    196|      is_enabled = options_->features.simd_enabled();
  911|    196|      break;
  912|    195|    case Type::FuncRef:
  ------------------
  |  Branch (912:5): [True: 195, False: 482k]
  ------------------
  913|    391|    case Type::ExternRef:
  ------------------
  |  Branch (913:5): [True: 196, False: 482k]
  ------------------
  914|    391|      is_enabled = options_->features.reference_types_enabled();
  915|    391|      break;
  916|    984|    case Type::ExnRef:
  ------------------
  |  Branch (916:5): [True: 984, False: 481k]
  ------------------
  917|    984|      is_enabled = options_->features.exceptions_enabled();
  918|    984|      break;
  919|   481k|    default:
  ------------------
  |  Branch (919:5): [True: 481k, False: 1.57k]
  ------------------
  920|   481k|      is_enabled = true;
  921|   481k|      break;
  922|   482k|  }
  923|       |
  924|   482k|  if (!is_enabled) {
  ------------------
  |  Branch (924:7): [True: 984, False: 481k]
  ------------------
  925|    984|    Error(token.loc, "value type not allowed: %s", type.GetName().c_str());
  926|    984|    return Result::Error;
  927|    984|  }
  928|       |
  929|   481k|  *out_type = Var(type, GetLocation());
  930|   481k|  return Result::Ok;
  931|   482k|}
_ZN4wabt10WastParser18ParseValueTypeListEPNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEEPNS2_INS0_12ReferenceVarENS4_IS8_EEEE:
  934|  27.2k|                                      ReferenceVars* type_vars) {
  935|  27.2k|  WABT_TRACE(ParseValueTypeList);
  936|  74.9k|  while (true) {
  ------------------
  |  Branch (936:10): [Folded - Ignored]
  ------------------
  937|  74.9k|    if (!PeekMatchRefType() && !PeekMatch(TokenType::ValueType)) {
  ------------------
  |  Branch (937:9): [True: 74.9k, False: 0]
  |  Branch (937:32): [True: 26.3k, False: 48.6k]
  ------------------
  938|  26.3k|      break;
  939|  26.3k|    }
  940|       |
  941|  48.6k|    Var type;
  942|  48.6k|    CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|  48.6k|  do {                              \
  |  |   56|  48.6k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 982, False: 47.6k]
  |  |  ------------------
  |  |   57|    982|      return ::wabt::Result::Error; \
  |  |   58|    982|    }                               \
  |  |   59|  48.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  943|       |
  944|  47.6k|    if (type.is_index()) {
  ------------------
  |  Branch (944:9): [True: 47.6k, False: 0]
  ------------------
  945|  47.6k|      if (IsIndexLikelyType(type.index())) {
  ------------------
  |  Branch (945:11): [True: 47.6k, False: 0]
  ------------------
  946|  47.6k|        out_type_list->push_back(Type(type.index()));
  947|  47.6k|      } else {
  948|      0|        type_vars->push_back(ReferenceVar(out_type_list->size(), type));
  949|      0|        out_type_list->push_back(Type(Type::Reference, type.index()));
  950|      0|      }
  951|  47.6k|    } else {
  952|      0|      assert(type.is_name());
  953|      0|      assert(options_->features.function_references_enabled());
  954|      0|      type_vars->push_back(ReferenceVar(out_type_list->size(), type));
  955|      0|      out_type_list->push_back(Type(Type::Reference, kInvalidIndex));
  956|      0|    }
  957|  47.6k|  }
  958|       |
  959|  26.3k|  return Result::Ok;
  960|  27.2k|}
_ZN4wabt10WastParser12ParseRefKindEPNS_4TypeE:
  962|  1.21k|Result WastParser::ParseRefKind(Type* out_type) {
  963|  1.21k|  WABT_TRACE(ParseRefKind);
  964|  1.21k|  if (!IsTokenTypeRefKind(Peek())) {
  ------------------
  |  Branch (964:7): [True: 710, False: 503]
  ------------------
  965|    710|    return ErrorExpected({"func", "extern", "exn"});
  966|    710|  }
  967|       |
  968|    503|  Token token = Consume();
  969|    503|  Type type = token.type();
  970|       |
  971|    503|  if ((type == Type::ExternRef &&
  ------------------
  |  Branch (971:8): [True: 202, False: 301]
  ------------------
  972|    503|       !options_->features.reference_types_enabled()) ||
  ------------------
  |  Branch (972:8): [True: 0, False: 202]
  ------------------
  973|    503|      ((type == Type::Struct || type == Type::Array) &&
  ------------------
  |  Branch (973:9): [True: 0, False: 503]
  |  Branch (973:33): [True: 0, False: 503]
  ------------------
  974|    503|       !options_->features.gc_enabled())) {
  ------------------
  |  Branch (974:8): [True: 0, False: 0]
  ------------------
  975|      0|    Error(token.loc, "value type not allowed: %s", type.GetName().c_str());
  976|      0|    return Result::Error;
  977|      0|  }
  978|       |
  979|    503|  *out_type = type;
  980|    503|  return Result::Ok;
  981|    503|}
_ZN4wabt10WastParser12ParseRefTypeEPNS_4TypeE:
  983|   134k|Result WastParser::ParseRefType(Type* out_type) {
  984|   134k|  WABT_TRACE(ParseRefType);
  985|   134k|  if (!PeekMatch(TokenType::ValueType)) {
  ------------------
  |  Branch (985:7): [True: 8.45k, False: 125k]
  ------------------
  986|  8.45k|    return ErrorExpected({"funcref", "externref", "exnref"});
  987|  8.45k|  }
  988|       |
  989|   125k|  Token token = Consume();
  990|   125k|  Type type = token.type();
  991|   125k|  if (type == Type::ExternRef &&
  ------------------
  |  Branch (991:7): [True: 194, False: 125k]
  ------------------
  992|   125k|      !options_->features.reference_types_enabled()) {
  ------------------
  |  Branch (992:7): [True: 0, False: 194]
  ------------------
  993|      0|    Error(token.loc, "value type not allowed: %s", type.GetName().c_str());
  994|      0|    return Result::Error;
  995|      0|  }
  996|       |
  997|   125k|  *out_type = type;
  998|   125k|  return Result::Ok;
  999|   125k|}
_ZN4wabt10WastParser15ParseRefTypeOptEPNS_4TypeE:
 1001|   260k|bool WastParser::ParseRefTypeOpt(Type* out_type) {
 1002|   260k|  WABT_TRACE(ParseRefTypeOpt);
 1003|   260k|  if (!PeekMatch(TokenType::ValueType)) {
  ------------------
  |  Branch (1003:7): [True: 259k, False: 1.53k]
  ------------------
 1004|   259k|    return false;
 1005|   259k|  }
 1006|       |
 1007|  1.53k|  Token token = Consume();
 1008|  1.53k|  Type type = token.type();
 1009|  1.53k|  if (type == Type::ExternRef &&
  ------------------
  |  Branch (1009:7): [True: 204, False: 1.33k]
  ------------------
 1010|  1.53k|      !options_->features.reference_types_enabled()) {
  ------------------
  |  Branch (1010:7): [True: 0, False: 204]
  ------------------
 1011|      0|    return false;
 1012|      0|  }
 1013|       |
 1014|  1.53k|  *out_type = type;
 1015|  1.53k|  return true;
 1016|  1.53k|}
_ZN4wabt10WastParser15ParseQuotedTextEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 1018|   663k|Result WastParser::ParseQuotedText(std::string* text, bool check_utf8) {
 1019|   663k|  WABT_TRACE(ParseQuotedText);
 1020|   663k|  if (!PeekMatch(TokenType::Text)) {
  ------------------
  |  Branch (1020:7): [True: 163k, False: 499k]
  ------------------
 1021|   163k|    return ErrorExpected({"a quoted string"}, "\"foo\"");
 1022|   163k|  }
 1023|       |
 1024|   499k|  Token token = Consume();
 1025|   499k|  RemoveEscapes(token.text(), std::back_inserter(*text));
 1026|   499k|  if (check_utf8 && !IsValidUtf8(text->data(), text->length())) {
  ------------------
  |  Branch (1026:7): [True: 494k, False: 4.78k]
  |  Branch (1026:21): [True: 11.7k, False: 483k]
  ------------------
 1027|  11.7k|    Error(token.loc, "quoted string has an invalid utf-8 encoding");
 1028|  11.7k|  }
 1029|   499k|  return Result::Ok;
 1030|   663k|}
_ZN4wabt10WastParser14ParseOffsetOptEPm:
 1032|  51.5k|bool WastParser::ParseOffsetOpt(Address* out_offset) {
 1033|  51.5k|  WABT_TRACE(ParseOffsetOpt);
 1034|  51.5k|  if (PeekMatch(TokenType::OffsetEqNat)) {
  ------------------
  |  Branch (1034:7): [True: 8.67k, False: 42.8k]
  ------------------
 1035|  8.67k|    Token token = Consume();
 1036|  8.67k|    uint64_t offset64;
 1037|  8.67k|    std::string_view sv = token.text();
 1038|  8.67k|    if (Failed(ParseInt64(sv, &offset64, ParseIntType::SignedAndUnsigned))) {
  ------------------
  |  Branch (1038:9): [True: 1.01k, False: 7.65k]
  ------------------
 1039|  1.01k|      Error(token.loc, "invalid offset \"" PRIstringview "\"",
 1040|  1.01k|            WABT_PRINTF_STRING_VIEW_ARG(sv));
  ------------------
  |  |   28|  1.01k|  static_cast<int>((x).length()), (x).data()
  ------------------
 1041|  1.01k|    }
 1042|       |    // With memory64, offsets > UINT32_MAX for i32 memories are no longer
 1043|       |    // malformed (just invalid)
 1044|  8.67k|    if ((!options_->features.memory64_enabled()) && (offset64 > UINT32_MAX)) {
  ------------------
  |  Branch (1044:9): [True: 8.67k, False: 0]
  |  Branch (1044:53): [True: 6.55k, False: 2.11k]
  ------------------
 1045|  6.55k|      Error(token.loc, "offset must be less than or equal to 0xffffffff");
 1046|  6.55k|    }
 1047|  8.67k|    *out_offset = offset64;
 1048|  8.67k|    return true;
 1049|  42.8k|  } else {
 1050|  42.8k|    *out_offset = 0;
 1051|  42.8k|    return false;
 1052|  42.8k|  }
 1053|  51.5k|}
_ZN4wabt10WastParser13ParseAlignOptEPm:
 1055|  51.5k|bool WastParser::ParseAlignOpt(Address* out_align) {
 1056|  51.5k|  WABT_TRACE(ParseAlignOpt);
 1057|  51.5k|  if (PeekMatch(TokenType::AlignEqNat)) {
  ------------------
  |  Branch (1057:7): [True: 819, False: 50.7k]
  ------------------
 1058|    819|    Token token = Consume();
 1059|    819|    std::string_view sv = token.text();
 1060|    819|    if (Failed(ParseInt64(sv, out_align, ParseIntType::UnsignedOnly))) {
  ------------------
  |  Branch (1060:9): [True: 265, False: 554]
  ------------------
 1061|    265|      Error(token.loc, "invalid alignment \"" PRIstringview "\"",
 1062|    265|            WABT_PRINTF_STRING_VIEW_ARG(sv));
  ------------------
  |  |   28|    265|  static_cast<int>((x).length()), (x).data()
  ------------------
 1063|    265|    }
 1064|       |
 1065|    819|    if (!IsPowerOfTwo(*out_align)) {
  ------------------
  |  Branch (1065:9): [True: 612, False: 207]
  ------------------
 1066|    612|      Error(token.loc, "alignment must be power-of-two");
 1067|    612|    }
 1068|       |
 1069|    819|    return true;
 1070|  50.7k|  } else {
 1071|  50.7k|    *out_align = WABT_USE_NATURAL_ALIGNMENT;
 1072|  50.7k|    return false;
 1073|  50.7k|  }
 1074|  51.5k|}
_ZN4wabt10WastParser11ParseMemidxENS_8LocationEPNS_3VarE:
 1076|  71.7k|Result WastParser::ParseMemidx(Location loc, Var* out_memidx) {
 1077|  71.7k|  WABT_TRACE(ParseMemidx);
 1078|  71.7k|  if (PeekMatchLpar(TokenType::Memory)) {
  ------------------
  |  Branch (1078:7): [True: 377, False: 71.3k]
  ------------------
 1079|    377|    if (!options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (1079:9): [True: 377, False: 0]
  ------------------
 1080|    377|      Error(loc, "Specifying memory variable is not allowed");
 1081|    377|      return Result::Error;
 1082|    377|    }
 1083|      0|    EXPECT(Lpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1084|      0|    EXPECT(Memory);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1085|      0|    CHECK_RESULT(ParseVar(out_memidx));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1086|      0|    EXPECT(Rpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1087|  71.3k|  } else {
 1088|  71.3k|    if (ParseVarOpt(out_memidx, Var(0, loc)) &&
  ------------------
  |  Branch (1088:9): [True: 15.0k, False: 56.2k]
  |  Branch (1088:9): [True: 15.0k, False: 56.2k]
  ------------------
 1089|  71.3k|        !options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (1089:9): [True: 15.0k, False: 0]
  ------------------
 1090|  15.0k|      Error(loc, "Specifying memory variable is not allowed");
 1091|  15.0k|      return Result::Error;
 1092|  15.0k|    }
 1093|  71.3k|  }
 1094|  56.2k|  return Result::Ok;
 1095|  71.7k|}
_ZN4wabt10WastParser16ParseLimitsIndexEPNS_6LimitsE:
 1097|   719k|Result WastParser::ParseLimitsIndex(Limits* out_limits) {
 1098|   719k|  WABT_TRACE(ParseLimitsIndex);
 1099|       |
 1100|   719k|  if (PeekMatch(TokenType::ValueType)) {
  ------------------
  |  Branch (1100:7): [True: 3.50k, False: 716k]
  ------------------
 1101|  3.50k|    if (GetToken().type() == Type::I64) {
  ------------------
  |  Branch (1101:9): [True: 789, False: 2.71k]
  ------------------
 1102|    789|      Consume();
 1103|    789|      out_limits->is_64 = true;
 1104|  2.71k|    } else if (GetToken().type() == Type::I32) {
  ------------------
  |  Branch (1104:16): [True: 355, False: 2.35k]
  ------------------
 1105|    355|      Consume();
 1106|    355|      out_limits->is_64 = false;
 1107|    355|    }
 1108|  3.50k|  }
 1109|       |
 1110|   719k|  return Result::Ok;
 1111|   719k|}
_ZN4wabt10WastParser11ParseLimitsEPNS_6LimitsE:
 1113|   716k|Result WastParser::ParseLimits(Limits* out_limits) {
 1114|   716k|  WABT_TRACE(ParseLimits);
 1115|       |
 1116|   716k|  CHECK_RESULT(ParseNat(&out_limits->initial, out_limits->is_64));
  ------------------
  |  |   55|   716k|  do {                              \
  |  |   56|   716k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 50.8k, False: 665k]
  |  |  ------------------
  |  |   57|  50.8k|      return ::wabt::Result::Error; \
  |  |   58|  50.8k|    }                               \
  |  |   59|   716k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1117|   665k|  if (PeekMatch(TokenType::Nat)) {
  ------------------
  |  Branch (1117:7): [True: 13.5k, False: 652k]
  ------------------
 1118|  13.5k|    CHECK_RESULT(ParseNat(&out_limits->max, out_limits->is_64));
  ------------------
  |  |   55|  13.5k|  do {                              \
  |  |   56|  13.5k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 13.5k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  13.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1119|  13.5k|    out_limits->has_max = true;
 1120|   652k|  } else {
 1121|   652k|    out_limits->has_max = false;
 1122|   652k|  }
 1123|       |
 1124|   665k|  if (Match(TokenType::Shared)) {
  ------------------
  |  Branch (1124:7): [True: 194, False: 665k]
  ------------------
 1125|    194|    out_limits->is_shared = true;
 1126|    194|  }
 1127|       |
 1128|   665k|  return Result::Ok;
 1129|   665k|}
_ZN4wabt10WastParser13ParsePageSizeEPj:
 1131|   534k|Result WastParser::ParsePageSize(uint32_t* out_page_size) {
 1132|   534k|  WABT_TRACE(ParsePageSize);
 1133|       |
 1134|   534k|  Result result = Result::Ok;
 1135|       |
 1136|   534k|  if (PeekMatchLpar(TokenType::PageSize)) {
  ------------------
  |  Branch (1136:7): [True: 0, False: 534k]
  ------------------
 1137|      0|    if (!options_->features.custom_page_sizes_enabled()) {
  ------------------
  |  Branch (1137:9): [True: 0, False: 0]
  ------------------
 1138|      0|      Error(GetLocation(), "Specifying memory page size is not allowed");
 1139|      0|      return Result::Error;
 1140|      0|    }
 1141|      0|    EXPECT(Lpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1142|      0|    EXPECT(PageSize);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1143|      0|    auto token = GetToken();
 1144|      0|    if (!token.HasLiteral()) {
  ------------------
  |  Branch (1144:9): [True: 0, False: 0]
  ------------------
 1145|      0|      Error(GetLocation(), "malformed custom page size");
 1146|      0|      return Result::Error;
 1147|      0|    }
 1148|      0|    auto sv = token.literal().text;
 1149|      0|    result |= ParseInt32(sv, out_page_size, ParseIntType::UnsignedOnly);
 1150|      0|    if (*out_page_size > UINT32_MAX || *out_page_size <= 0 ||
  ------------------
  |  Branch (1150:9): [True: 0, False: 0]
  |  Branch (1150:40): [True: 0, False: 0]
  ------------------
 1151|      0|        (*out_page_size & (*out_page_size - 1))) {
  ------------------
  |  Branch (1151:9): [True: 0, False: 0]
  ------------------
 1152|      0|      Error(GetLocation(), "malformed custom page size");
 1153|      0|      return Result::Error;
 1154|      0|    }
 1155|      0|    Consume();
 1156|      0|    EXPECT(Rpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1157|      0|  }
 1158|       |
 1159|   534k|  return result;
 1160|   534k|}
_ZN4wabt10WastParser8ParseNatEPmb:
 1162|   729k|Result WastParser::ParseNat(uint64_t* out_nat, bool is_64) {
 1163|   729k|  WABT_TRACE(ParseNat);
 1164|   729k|  if (!PeekMatch(TokenType::Nat)) {
  ------------------
  |  Branch (1164:7): [True: 50.8k, False: 679k]
  ------------------
 1165|  50.8k|    return ErrorExpected({"a natural number"}, "123");
 1166|  50.8k|  }
 1167|       |
 1168|   679k|  Token token = Consume();
 1169|   679k|  std::string_view sv = token.literal().text;
 1170|   679k|  if (Failed(ParseUint64(sv, out_nat)) || (!is_64 && *out_nat > 0xffffffffu)) {
  ------------------
  |  Branch (1170:7): [True: 4.40k, False: 674k]
  |  Branch (1170:44): [True: 674k, False: 210]
  |  Branch (1170:54): [True: 1.71k, False: 672k]
  ------------------
 1171|  6.11k|    Error(token.loc, "invalid int \"" PRIstringview "\"",
 1172|  6.11k|          WABT_PRINTF_STRING_VIEW_ARG(sv));
  ------------------
  |  |   28|  6.11k|  static_cast<int>((x).length()), (x).data()
  ------------------
 1173|  6.11k|  }
 1174|       |
 1175|   679k|  return Result::Ok;
 1176|   729k|}
_ZN4wabt10WastParser11ParseModuleEPNSt3__110unique_ptrINS_6ModuleENS1_14default_deleteIS3_EEEE:
 1178|  23.2k|Result WastParser::ParseModule(std::unique_ptr<Module>* out_module) {
 1179|  23.2k|  WABT_TRACE(ParseModule);
 1180|  23.2k|  auto module = std::make_unique<Module>();
 1181|       |
 1182|  23.2k|  if (PeekMatchLpar(TokenType::Module)) {
  ------------------
  |  Branch (1182:7): [True: 80, False: 23.1k]
  ------------------
 1183|       |    // Starts with "(module". Allow text and binary modules, but no quoted
 1184|       |    // modules.
 1185|     80|    CommandPtr command;
 1186|     80|    CHECK_RESULT(ParseModuleCommand(nullptr, &command));
  ------------------
  |  |   55|     80|  do {                              \
  |  |   56|     80|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 26, False: 54]
  |  |  ------------------
  |  |   57|     26|      return ::wabt::Result::Error; \
  |  |   58|     26|    }                               \
  |  |   59|     80|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1187|     54|    if (isa<ModuleCommand>(command.get())) {
  ------------------
  |  Branch (1187:9): [True: 54, False: 0]
  ------------------
 1188|     54|      auto module_command = cast<ModuleCommand>(std::move(command));
 1189|     54|      *module = std::move(module_command->module);
 1190|     54|    } else {
 1191|      0|      assert(isa<ScriptModuleCommand>(command.get()));
 1192|      0|      auto module_command = cast<ScriptModuleCommand>(std::move(command));
 1193|      0|      *module = std::move(module_command->module);
 1194|      0|    }
 1195|  23.1k|  } else if (IsModuleField(PeekPair()) || PeekIsCustom()) {
  ------------------
  |  Branch (1195:14): [True: 21.1k, False: 2.01k]
  |  Branch (1195:43): [True: 0, False: 2.01k]
  ------------------
 1196|       |    // Parse an inline module (i.e. one with no surrounding (module)).
 1197|  21.1k|    CHECK_RESULT(ParseModuleFieldList(module.get()));
  ------------------
  |  |   55|  21.1k|  do {                              \
  |  |   56|  21.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 18.9k, False: 2.16k]
  |  |  ------------------
  |  |   57|  18.9k|      return ::wabt::Result::Error; \
  |  |   58|  18.9k|    }                               \
  |  |   59|  21.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1198|  21.1k|  } else if (PeekMatch(TokenType::Eof)) {
  ------------------
  |  Branch (1198:14): [True: 715, False: 1.29k]
  ------------------
 1199|    715|    errors_->emplace_back(ErrorLevel::Warning, GetLocation(), "empty module");
 1200|  1.29k|  } else {
 1201|  1.29k|    ConsumeIfLpar();
 1202|  1.29k|    ErrorExpected({"a module field", "a module"});
 1203|  1.29k|  }
 1204|       |
 1205|  4.23k|  EXPECT(Eof);
  ------------------
  |  |   31|  4.23k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  4.23k|  do {                              \
  |  |  |  |   56|  4.23k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 767, False: 3.46k]
  |  |  |  |  ------------------
  |  |  |  |   57|    767|      return ::wabt::Result::Error; \
  |  |  |  |   58|    767|    }                               \
  |  |  |  |   59|  4.23k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1206|  3.46k|  if (!HasError()) {
  ------------------
  |  Branch (1206:7): [True: 1.61k, False: 1.85k]
  ------------------
 1207|  1.61k|    *out_module = std::move(module);
 1208|  1.61k|    return Result::Ok;
 1209|  1.85k|  } else {
 1210|  1.85k|    return Result::Error;
 1211|  1.85k|  }
 1212|  3.46k|}
_ZN4wabt10WastParser12PeekIsCustomEv:
 1294|  3.76M|bool WastParser::PeekIsCustom() {
 1295|       |  // If IsLparAnn succeeds, tokens_.front() must have text, as it is an LparAnn
 1296|       |  // token.
 1297|  3.76M|  return options_->features.annotations_enabled() && IsLparAnn(PeekPair()) &&
  ------------------
  |  Branch (1297:10): [True: 0, False: 3.76M]
  |  Branch (1297:54): [True: 0, False: 0]
  ------------------
 1298|  3.76M|         tokens_.front().text() == "custom";
  ------------------
  |  Branch (1298:10): [True: 0, False: 0]
  ------------------
 1299|  3.76M|}
_ZN4wabt10WastParser20ParseModuleFieldListEPNS_6ModuleE:
 1354|  21.1k|Result WastParser::ParseModuleFieldList(Module* module) {
 1355|  21.1k|  WABT_TRACE(ParseModuleFieldList);
 1356|       |
 1357|       |  // Reset module-specific state.
 1358|  21.1k|  resolve_types_.clear();
 1359|  21.1k|  resolve_funcs_.clear();
 1360|       |
 1361|  3.76M|  while (IsModuleField(PeekPair()) || PeekIsCustom()) {
  ------------------
  |  Branch (1361:10): [True: 3.75M, False: 6.93k]
  |  Branch (1361:39): [True: 0, False: 6.93k]
  ------------------
 1362|  3.75M|    if (PeekIsCustom()) {
  ------------------
  |  Branch (1362:9): [True: 0, False: 3.75M]
  ------------------
 1363|      0|      CHECK_RESULT(ParseCustomSectionAnnotation(module));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1364|      0|      continue;
 1365|      0|    }
 1366|  3.75M|    if (Failed(ParseModuleField(module))) {
  ------------------
  |  Branch (1366:9): [True: 2.86M, False: 891k]
  ------------------
 1367|  2.86M|      CHECK_RESULT(Synchronize(IsModuleField));
  ------------------
  |  |   55|  2.86M|  do {                              \
  |  |   56|  2.86M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 14.2k, False: 2.84M]
  |  |  ------------------
  |  |   57|  14.2k|      return ::wabt::Result::Error; \
  |  |   58|  14.2k|    }                               \
  |  |   59|  2.86M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1368|  2.86M|    }
 1369|  3.75M|  }
 1370|       |
 1371|       |  // Module parsing is completed, type names can be resolved now.
 1372|  6.93k|  Result result = Result::Ok;
 1373|       |
 1374|  6.93k|  for (auto it : resolve_types_) {
  ------------------
  |  Branch (1374:16): [True: 0, False: 6.93k]
  ------------------
 1375|      0|    result |= ResolveRefTypes(*module, it.target_types, &it.vars, errors_);
 1376|      0|  }
 1377|       |
 1378|  6.93k|  for (auto it : resolve_funcs_) {
  ------------------
  |  Branch (1378:16): [True: 0, False: 6.93k]
  ------------------
 1379|      0|    result |= ResolveRefTypes(*module, &it.types, &it.vars, errors_);
 1380|      0|    it.target_func->local_types.Set(it.types);
 1381|      0|  }
 1382|       |
 1383|  6.93k|  CHECK_RESULT(result);
  ------------------
  |  |   55|  6.93k|  do {                              \
  |  |   56|  6.93k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 6.93k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  6.93k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1384|  6.93k|  CHECK_RESULT(ResolveFuncTypes(module, errors_));
  ------------------
  |  |   55|  6.93k|  do {                              \
  |  |   56|  6.93k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 292, False: 6.64k]
  |  |  ------------------
  |  |   57|    292|      return ::wabt::Result::Error; \
  |  |   58|    292|    }                               \
  |  |   59|  6.93k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1385|  6.64k|  CHECK_RESULT(ResolveNamesModule(module, errors_));
  ------------------
  |  |   55|  6.64k|  do {                              \
  |  |   56|  6.64k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 4.41k, False: 2.22k]
  |  |  ------------------
  |  |   57|  4.41k|      return ::wabt::Result::Error; \
  |  |   58|  4.41k|    }                               \
  |  |   59|  6.64k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1386|  2.22k|  return Result::Ok;
 1387|  6.64k|}
_ZN4wabt10WastParser16ParseModuleFieldEPNS_6ModuleE:
 1389|  3.75M|Result WastParser::ParseModuleField(Module* module) {
 1390|  3.75M|  WABT_TRACE(ParseModuleField);
 1391|  3.75M|  switch (Peek(1)) {
 1392|  96.7k|    case TokenType::Data:   return ParseDataModuleField(module);
  ------------------
  |  Branch (1392:5): [True: 96.7k, False: 3.65M]
  ------------------
 1393|   262k|    case TokenType::Elem:   return ParseElemModuleField(module);
  ------------------
  |  Branch (1393:5): [True: 262k, False: 3.49M]
  ------------------
 1394|  50.5k|    case TokenType::Tag:    return ParseTagModuleField(module);
  ------------------
  |  Branch (1394:5): [True: 50.5k, False: 3.70M]
  ------------------
 1395|  12.5k|    case TokenType::Export: return ParseExportModuleField(module);
  ------------------
  |  Branch (1395:5): [True: 12.5k, False: 3.74M]
  ------------------
 1396|  1.81M|    case TokenType::Func:   return ParseFuncModuleField(module);
  ------------------
  |  Branch (1396:5): [True: 1.81M, False: 1.94M]
  ------------------
 1397|   122k|    case TokenType::Type:   return ParseTypeModuleField(module);
  ------------------
  |  Branch (1397:5): [True: 122k, False: 3.63M]
  ------------------
 1398|   521k|    case TokenType::Global: return ParseGlobalModuleField(module);
  ------------------
  |  Branch (1398:5): [True: 521k, False: 3.23M]
  ------------------
 1399|   150k|    case TokenType::Import: return ParseImportModuleField(module);
  ------------------
  |  Branch (1399:5): [True: 150k, False: 3.60M]
  ------------------
 1400|   552k|    case TokenType::Memory: return ParseMemoryModuleField(module);
  ------------------
  |  Branch (1400:5): [True: 552k, False: 3.20M]
  ------------------
 1401|  1.06k|    case TokenType::Start:  return ParseStartModuleField(module);
  ------------------
  |  Branch (1401:5): [True: 1.06k, False: 3.75M]
  ------------------
 1402|   170k|    case TokenType::Table:  return ParseTableModuleField(module);
  ------------------
  |  Branch (1402:5): [True: 170k, False: 3.58M]
  ------------------
 1403|      0|    default:
  ------------------
  |  Branch (1403:5): [True: 0, False: 3.75M]
  ------------------
 1404|      0|      assert(
 1405|      0|          !"ParseModuleField should only be called if IsModuleField() is true");
 1406|      0|      return Result::Error;
 1407|  3.75M|  }
 1408|  3.75M|}
_ZN4wabt10WastParser20ParseDataModuleFieldEPNS_6ModuleE:
 1410|  96.7k|Result WastParser::ParseDataModuleField(Module* module) {
 1411|  96.7k|  WABT_TRACE(ParseDataModuleField);
 1412|  96.7k|  EXPECT(Lpar);
  ------------------
  |  |   31|  96.7k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  96.7k|  do {                              \
  |  |  |  |   56|  96.7k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 96.7k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  96.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1413|  96.7k|  Location loc = GetLocation();
 1414|  96.7k|  EXPECT(Data);
  ------------------
  |  |   31|  96.7k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  96.7k|  do {                              \
  |  |  |  |   56|  96.7k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 96.7k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  96.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1415|  96.7k|  std::string name;
 1416|  96.7k|  ParseBindVarOpt(&name);
 1417|  96.7k|  auto field = std::make_unique<DataSegmentModuleField>(loc, name);
 1418|       |
 1419|  96.7k|  if (PeekMatchLpar(TokenType::Memory)) {
  ------------------
  |  Branch (1419:7): [True: 19.3k, False: 77.3k]
  ------------------
 1420|  19.3k|    EXPECT(Lpar);
  ------------------
  |  |   31|  19.3k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  19.3k|  do {                              \
  |  |  |  |   56|  19.3k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 19.3k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  19.3k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1421|  19.3k|    EXPECT(Memory);
  ------------------
  |  |   31|  19.3k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  19.3k|  do {                              \
  |  |  |  |   56|  19.3k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 19.3k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  19.3k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1422|  19.3k|    CHECK_RESULT(ParseVar(&field->data_segment.memory_var));
  ------------------
  |  |   55|  19.3k|  do {                              \
  |  |   56|  19.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.18k, False: 18.1k]
  |  |  ------------------
  |  |   57|  1.18k|      return ::wabt::Result::Error; \
  |  |   58|  1.18k|    }                               \
  |  |   59|  19.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1423|  18.1k|    EXPECT(Rpar);
  ------------------
  |  |   31|  18.1k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  18.1k|  do {                              \
  |  |  |  |   56|  18.1k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 17.7k, False: 403]
  |  |  |  |  ------------------
  |  |  |  |   57|  17.7k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  17.7k|    }                               \
  |  |  |  |   59|  18.1k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1424|    403|    CHECK_RESULT(ParseOffsetExpr(&field->data_segment.offset));
  ------------------
  |  |   55|    403|  do {                              \
  |  |   56|    403|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 198, False: 205]
  |  |  ------------------
  |  |   57|    198|      return ::wabt::Result::Error; \
  |  |   58|    198|    }                               \
  |  |   59|    403|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1425|  77.3k|  } else if (ParseVarOpt(&field->data_segment.memory_var, Var(0, loc))) {
  ------------------
  |  Branch (1425:14): [True: 3.22k, False: 74.1k]
  ------------------
 1426|  3.22k|    CHECK_RESULT(ParseOffsetExpr(&field->data_segment.offset));
  ------------------
  |  |   55|  3.22k|  do {                              \
  |  |   56|  3.22k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.25k, False: 968]
  |  |  ------------------
  |  |   57|  2.25k|      return ::wabt::Result::Error; \
  |  |   58|  2.25k|    }                               \
  |  |   59|  3.22k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1427|  74.1k|  } else if (!ParseOffsetExprOpt(&field->data_segment.offset)) {
  ------------------
  |  Branch (1427:14): [True: 73.0k, False: 1.09k]
  ------------------
 1428|  73.0k|    if (!options_->features.bulk_memory_enabled()) {
  ------------------
  |  Branch (1428:9): [True: 0, False: 73.0k]
  ------------------
 1429|      0|      Error(loc, "passive data segments are not allowed");
 1430|      0|      return Result::Error;
 1431|      0|    }
 1432|       |
 1433|  73.0k|    field->data_segment.kind = SegmentKind::Passive;
 1434|  73.0k|  }
 1435|       |
 1436|  75.3k|  ParseTextListOpt(&field->data_segment.data);
 1437|  75.3k|  EXPECT(Rpar);
  ------------------
  |  |   31|  75.3k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  75.3k|  do {                              \
  |  |  |  |   56|  75.3k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 16.3k, False: 59.0k]
  |  |  |  |  ------------------
  |  |  |  |   57|  16.3k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  16.3k|    }                               \
  |  |  |  |   59|  75.3k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1438|  59.0k|  module->AppendField(std::move(field));
 1439|  59.0k|  return Result::Ok;
 1440|  75.3k|}
_ZN4wabt10WastParser20ParseElemModuleFieldEPNS_6ModuleE:
 1442|   262k|Result WastParser::ParseElemModuleField(Module* module) {
 1443|   262k|  WABT_TRACE(ParseElemModuleField);
 1444|   262k|  EXPECT(Lpar);
  ------------------
  |  |   31|   262k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   262k|  do {                              \
  |  |  |  |   56|   262k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 262k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   262k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1445|   262k|  Location loc = GetLocation();
 1446|   262k|  EXPECT(Elem);
  ------------------
  |  |   31|   262k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   262k|  do {                              \
  |  |  |  |   56|   262k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 262k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   262k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1447|       |
 1448|       |  // With MVP text format the name here was intended to refer to the table
 1449|       |  // that the elem segment was part of, but we never did anything with this name
 1450|       |  // since there was only one table anyway.
 1451|       |  // With bulk-memory enabled this introduces a new name for the particular
 1452|       |  // elem segment.
 1453|   262k|  std::string initial_name;
 1454|   262k|  bool has_name = ParseBindVarOpt(&initial_name);
 1455|       |
 1456|   262k|  std::string segment_name = initial_name;
 1457|   262k|  if (!options_->features.bulk_memory_enabled()) {
  ------------------
  |  Branch (1457:7): [True: 0, False: 262k]
  ------------------
 1458|      0|    segment_name = "";
 1459|      0|  }
 1460|   262k|  auto field = std::make_unique<ElemSegmentModuleField>(loc, segment_name);
 1461|   262k|  if (options_->features.reference_types_enabled() &&
  ------------------
  |  Branch (1461:7): [True: 262k, False: 0]
  ------------------
 1462|   262k|      Match(TokenType::Declare)) {
  ------------------
  |  Branch (1462:7): [True: 195, False: 262k]
  ------------------
 1463|    195|    field->elem_segment.kind = SegmentKind::Declared;
 1464|    195|  }
 1465|       |
 1466|       |  // Optional table specifier
 1467|   262k|  if (options_->features.bulk_memory_enabled()) {
  ------------------
  |  Branch (1467:7): [True: 262k, False: 0]
  ------------------
 1468|   262k|    if (PeekMatchLpar(TokenType::Table)) {
  ------------------
  |  Branch (1468:9): [True: 1.50k, False: 260k]
  ------------------
 1469|  1.50k|      EXPECT(Lpar);
  ------------------
  |  |   31|  1.50k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.50k|  do {                              \
  |  |  |  |   56|  1.50k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 1.50k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  1.50k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1470|  1.50k|      EXPECT(Table);
  ------------------
  |  |   31|  1.50k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.50k|  do {                              \
  |  |  |  |   56|  1.50k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 1.50k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  1.50k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1471|  1.50k|      CHECK_RESULT(ParseVar(&field->elem_segment.table_var));
  ------------------
  |  |   55|  1.50k|  do {                              \
  |  |   56|  1.50k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.09k, False: 414]
  |  |  ------------------
  |  |   57|  1.09k|      return ::wabt::Result::Error; \
  |  |   58|  1.09k|    }                               \
  |  |   59|  1.50k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1472|    414|      EXPECT(Rpar);
  ------------------
  |  |   31|    414|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    414|  do {                              \
  |  |  |  |   56|    414|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 211, False: 203]
  |  |  |  |  ------------------
  |  |  |  |   57|    211|      return ::wabt::Result::Error; \
  |  |  |  |   58|    211|    }                               \
  |  |  |  |   59|    414|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1473|   260k|    } else {
 1474|   260k|      ParseVarOpt(&field->elem_segment.table_var, Var(0, loc));
 1475|   260k|    }
 1476|   262k|  } else {
 1477|      0|    if (has_name) {
  ------------------
  |  Branch (1477:9): [True: 0, False: 0]
  ------------------
 1478|      0|      field->elem_segment.table_var = Var(initial_name, loc);
 1479|      0|    } else {
 1480|      0|      ParseVarOpt(&field->elem_segment.table_var, Var(0, loc));
 1481|      0|    }
 1482|      0|  }
 1483|       |
 1484|       |  // Parse offset expression, if not declared/passive segment.
 1485|   260k|  if (options_->features.bulk_memory_enabled()) {
  ------------------
  |  Branch (1485:7): [True: 260k, False: 0]
  ------------------
 1486|   260k|    if (field->elem_segment.kind != SegmentKind::Declared &&
  ------------------
  |  Branch (1486:9): [True: 260k, False: 195]
  ------------------
 1487|   260k|        !ParseOffsetExprOpt(&field->elem_segment.offset)) {
  ------------------
  |  Branch (1487:9): [True: 227k, False: 33.5k]
  ------------------
 1488|   227k|      field->elem_segment.kind = SegmentKind::Passive;
 1489|   227k|    }
 1490|   260k|  } else {
 1491|      0|    CHECK_RESULT(ParseOffsetExpr(&field->elem_segment.offset));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1492|      0|  }
 1493|       |
 1494|   260k|  if (ParseRefTypeOpt(&field->elem_segment.elem_type)) {
  ------------------
  |  Branch (1494:7): [True: 1.53k, False: 259k]
  ------------------
 1495|  1.53k|    ParseElemExprListOpt(&field->elem_segment.elem_exprs);
 1496|   259k|  } else {
 1497|   259k|    field->elem_segment.elem_type = Type::FuncRef;
 1498|   259k|    if (PeekMatch(TokenType::Func)) {
  ------------------
  |  Branch (1498:9): [True: 229, False: 259k]
  ------------------
 1499|    229|      EXPECT(Func);
  ------------------
  |  |   31|    229|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    229|  do {                              \
  |  |  |  |   56|    229|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 229]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|    229|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1500|    229|    }
 1501|   259k|    ParseElemExprVarListOpt(&field->elem_segment.elem_exprs);
 1502|   259k|  }
 1503|   260k|  EXPECT(Rpar);
  ------------------
  |  |   31|   260k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   260k|  do {                              \
  |  |  |  |   56|   260k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 22.7k, False: 238k]
  |  |  |  |  ------------------
  |  |  |  |   57|  22.7k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  22.7k|    }                               \
  |  |  |  |   59|   260k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1504|   238k|  module->AppendField(std::move(field));
 1505|   238k|  return Result::Ok;
 1506|   260k|}
_ZN4wabt10WastParser19ParseTagModuleFieldEPNS_6ModuleE:
 1508|  50.5k|Result WastParser::ParseTagModuleField(Module* module) {
 1509|  50.5k|  WABT_TRACE(ParseTagModuleField);
 1510|  50.5k|  if (!options_->features.exceptions_enabled()) {
  ------------------
  |  Branch (1510:7): [True: 50.5k, False: 0]
  ------------------
 1511|  50.5k|    Error(Consume().loc, "tag not allowed");
 1512|  50.5k|    return Result::Error;
 1513|  50.5k|  }
 1514|      0|  EXPECT(Lpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1515|      0|  EXPECT(Tag);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1516|      0|  Location loc = GetLocation();
 1517|       |
 1518|      0|  std::string name;
 1519|      0|  ParseBindVarOpt(&name);
 1520|       |
 1521|      0|  ModuleFieldList export_fields;
 1522|      0|  CHECK_RESULT(ParseInlineExports(&export_fields, ExternalKind::Tag));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1523|       |
 1524|      0|  if (PeekMatchLpar(TokenType::Import)) {
  ------------------
  |  Branch (1524:7): [True: 0, False: 0]
  ------------------
 1525|      0|    CheckImportOrdering(module);
 1526|      0|    auto import = std::make_unique<TagImport>(name);
 1527|      0|    Tag& tag = import->tag;
 1528|      0|    CHECK_RESULT(ParseInlineImport(import.get()));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1529|      0|    CHECK_RESULT(ParseTypeUseOpt(&tag.decl));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1530|      0|    CHECK_RESULT(ParseUnboundFuncSignature(&tag.decl.sig));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1531|      0|    CHECK_RESULT(ErrorIfLpar({"type", "param", "result"}));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1532|      0|    auto field =
 1533|      0|        std::make_unique<ImportModuleField>(std::move(import), GetLocation());
 1534|      0|    module->AppendField(std::move(field));
 1535|      0|  } else {
 1536|      0|    auto field = std::make_unique<TagModuleField>(loc, name);
 1537|      0|    CHECK_RESULT(ParseTypeUseOpt(&field->tag.decl));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1538|      0|    CHECK_RESULT(ParseUnboundFuncSignature(&field->tag.decl.sig));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1539|      0|    module->AppendField(std::move(field));
 1540|      0|  }
 1541|       |
 1542|      0|  AppendInlineExportFields(module, &export_fields, module->tags.size() - 1);
 1543|       |
 1544|      0|  EXPECT(Rpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1545|      0|  return Result::Ok;
 1546|      0|}
_ZN4wabt10WastParser22ParseExportModuleFieldEPNS_6ModuleE:
 1548|  12.5k|Result WastParser::ParseExportModuleField(Module* module) {
 1549|  12.5k|  WABT_TRACE(ParseExportModuleField);
 1550|  12.5k|  EXPECT(Lpar);
  ------------------
  |  |   31|  12.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  12.5k|  do {                              \
  |  |  |  |   56|  12.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 12.5k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  12.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1551|  12.5k|  auto field = std::make_unique<ExportModuleField>(GetLocation());
 1552|  12.5k|  EXPECT(Export);
  ------------------
  |  |   31|  12.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  12.5k|  do {                              \
  |  |  |  |   56|  12.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 12.5k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  12.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1553|  12.5k|  CHECK_RESULT(ParseQuotedText(&field->export_.name));
  ------------------
  |  |   55|  12.5k|  do {                              \
  |  |   56|  12.5k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.83k, False: 10.7k]
  |  |  ------------------
  |  |   57|  1.83k|      return ::wabt::Result::Error; \
  |  |   58|  1.83k|    }                               \
  |  |   59|  12.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1554|  10.7k|  CHECK_RESULT(ParseExportDesc(&field->export_));
  ------------------
  |  |   55|  10.7k|  do {                              \
  |  |   56|  10.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 6.39k, False: 4.30k]
  |  |  ------------------
  |  |   57|  6.39k|      return ::wabt::Result::Error; \
  |  |   58|  6.39k|    }                               \
  |  |   59|  10.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1555|  4.30k|  EXPECT(Rpar);
  ------------------
  |  |   31|  4.30k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  4.30k|  do {                              \
  |  |  |  |   56|  4.30k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 238, False: 4.06k]
  |  |  |  |  ------------------
  |  |  |  |   57|    238|      return ::wabt::Result::Error; \
  |  |  |  |   58|    238|    }                               \
  |  |  |  |   59|  4.30k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1556|  4.06k|  module->AppendField(std::move(field));
 1557|  4.06k|  return Result::Ok;
 1558|  4.30k|}
_ZN4wabt10WastParser20ParseFuncModuleFieldEPNS_6ModuleE:
 1560|  1.81M|Result WastParser::ParseFuncModuleField(Module* module) {
 1561|  1.81M|  WABT_TRACE(ParseFuncModuleField);
 1562|  1.81M|  EXPECT(Lpar);
  ------------------
  |  |   31|  1.81M|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.81M|  do {                              \
  |  |  |  |   56|  1.81M|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 1.81M]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  1.81M|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1563|  1.81M|  Location loc = GetLocation();
 1564|  1.81M|  EXPECT(Func);
  ------------------
  |  |   31|  1.81M|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.81M|  do {                              \
  |  |  |  |   56|  1.81M|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 1.81M]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  1.81M|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1565|  1.81M|  std::string name;
 1566|  1.81M|  ParseBindVarOpt(&name);
 1567|       |
 1568|  1.81M|  ModuleFieldList export_fields;
 1569|  1.81M|  CHECK_RESULT(ParseInlineExports(&export_fields, ExternalKind::Func));
  ------------------
  |  |   55|  1.81M|  do {                              \
  |  |   56|  1.81M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 379, False: 1.81M]
  |  |  ------------------
  |  |   57|    379|      return ::wabt::Result::Error; \
  |  |   58|    379|    }                               \
  |  |   59|  1.81M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1570|       |
 1571|  1.81M|  if (PeekMatchLpar(TokenType::Import)) {
  ------------------
  |  Branch (1571:7): [True: 85.9k, False: 1.72M]
  ------------------
 1572|  85.9k|    CheckImportOrdering(module);
 1573|  85.9k|    auto import = std::make_unique<FuncImport>(name);
 1574|  85.9k|    Func& func = import->func;
 1575|  85.9k|    CHECK_RESULT(ParseInlineImport(import.get()));
  ------------------
  |  |   55|  85.9k|  do {                              \
  |  |   56|  85.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 11.4k, False: 74.4k]
  |  |  ------------------
  |  |   57|  11.4k|      return ::wabt::Result::Error; \
  |  |   58|  11.4k|    }                               \
  |  |   59|  85.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1576|  74.4k|    CHECK_RESULT(ParseTypeUseOpt(&func.decl));
  ------------------
  |  |   55|  74.4k|  do {                              \
  |  |   56|  74.4k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 474, False: 74.0k]
  |  |  ------------------
  |  |   57|    474|      return ::wabt::Result::Error; \
  |  |   58|    474|    }                               \
  |  |   59|  74.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1577|  74.0k|    CHECK_RESULT(ParseFuncSignature(&func.decl.sig, &func.bindings));
  ------------------
  |  |   55|  74.0k|  do {                              \
  |  |   56|  74.0k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 223, False: 73.7k]
  |  |  ------------------
  |  |   57|    223|      return ::wabt::Result::Error; \
  |  |   58|    223|    }                               \
  |  |   59|  74.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1578|  73.7k|    CHECK_RESULT(ErrorIfLpar({"type", "param", "result"}));
  ------------------
  |  |   55|  73.7k|  do {                              \
  |  |   56|  73.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 538, False: 73.2k]
  |  |  ------------------
  |  |   57|    538|      return ::wabt::Result::Error; \
  |  |   58|    538|    }                               \
  |  |   59|  73.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1579|  73.2k|    auto field =
 1580|  73.2k|        std::make_unique<ImportModuleField>(std::move(import), GetLocation());
 1581|  73.2k|    module->AppendField(std::move(field));
 1582|  1.72M|  } else {
 1583|  1.72M|    auto field = std::make_unique<FuncModuleField>(loc, name);
 1584|  1.72M|    Func& func = field->func;
 1585|  1.72M|    func.loc = GetLocation();
 1586|  1.72M|    CHECK_RESULT(ParseTypeUseOpt(&func.decl));
  ------------------
  |  |   55|  1.72M|  do {                              \
  |  |   56|  1.72M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 996, False: 1.72M]
  |  |  ------------------
  |  |   57|    996|      return ::wabt::Result::Error; \
  |  |   58|    996|    }                               \
  |  |   59|  1.72M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1587|  1.72M|    CHECK_RESULT(ParseFuncSignature(&func.decl.sig, &func.bindings));
  ------------------
  |  |   55|  1.72M|  do {                              \
  |  |   56|  1.72M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.59k, False: 1.72M]
  |  |  ------------------
  |  |   57|  3.59k|      return ::wabt::Result::Error; \
  |  |   58|  3.59k|    }                               \
  |  |   59|  1.72M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1588|       |
 1589|  1.72M|    ResolveFuncs references(&func);
 1590|       |
 1591|  1.72M|    CHECK_RESULT(ParseBoundValueTypeList(TokenType::Local, &references.types,
  ------------------
  |  |   55|  1.72M|  do {                              \
  |  |   56|  1.72M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.59k, False: 1.71M]
  |  |  ------------------
  |  |   57|  1.59k|      return ::wabt::Result::Error; \
  |  |   58|  1.59k|    }                               \
  |  |   59|  1.72M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1592|  1.72M|                                         &func.bindings, &references.vars,
 1593|  1.72M|                                         func.GetNumParams()));
 1594|       |
 1595|  1.71M|    if (references.vars.empty()) {
  ------------------
  |  Branch (1595:9): [True: 1.71M, False: 0]
  ------------------
 1596|       |      // No named references in the list, local types can be processed now.
 1597|  1.71M|      func.local_types.Set(references.types);
 1598|  1.71M|    } else {
 1599|      0|      resolve_funcs_.push_back(references);
 1600|      0|    }
 1601|       |
 1602|  1.71M|    CHECK_RESULT(ParseTerminatingInstrList(&func.exprs));
  ------------------
  |  |   55|  1.71M|  do {                              \
  |  |   56|  1.71M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 100k, False: 1.61M]
  |  |  ------------------
  |  |   57|   100k|      return ::wabt::Result::Error; \
  |  |   58|   100k|    }                               \
  |  |   59|  1.71M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1603|  1.61M|    module->AppendField(std::move(field));
 1604|  1.61M|  }
 1605|       |
 1606|  1.69M|  AppendInlineExportFields(module, &export_fields, module->funcs.size() - 1);
 1607|       |
 1608|  1.69M|  EXPECT(Rpar);
  ------------------
  |  |   31|  1.69M|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.69M|  do {                              \
  |  |  |  |   56|  1.69M|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 1.32M, False: 363k]
  |  |  |  |  ------------------
  |  |  |  |   57|  1.32M|      return ::wabt::Result::Error; \
  |  |  |  |   58|  1.32M|    }                               \
  |  |  |  |   59|  1.69M|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1609|   363k|  return Result::Ok;
 1610|  1.69M|}
_ZN4wabt10WastParser20ParseTypeModuleFieldEPNS_6ModuleE:
 1612|   122k|Result WastParser::ParseTypeModuleField(Module* module) {
 1613|   122k|  WABT_TRACE(ParseTypeModuleField);
 1614|   122k|  EXPECT(Lpar);
  ------------------
  |  |   31|   122k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   122k|  do {                              \
  |  |  |  |   56|   122k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 122k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   122k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1615|   122k|  auto field = std::make_unique<TypeModuleField>(GetLocation());
 1616|   122k|  EXPECT(Type);
  ------------------
  |  |   31|   122k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   122k|  do {                              \
  |  |  |  |   56|   122k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 122k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   122k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1617|       |
 1618|   122k|  std::string name;
 1619|   122k|  ParseBindVarOpt(&name);
 1620|   122k|  EXPECT(Lpar);
  ------------------
  |  |   31|   122k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   122k|  do {                              \
  |  |  |  |   56|   122k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 3.57k, False: 119k]
  |  |  |  |  ------------------
  |  |  |  |   57|  3.57k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  3.57k|    }                               \
  |  |  |  |   59|   122k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1621|   119k|  Location loc = GetLocation();
 1622|       |
 1623|   119k|  if (Match(TokenType::Func)) {
  ------------------
  |  Branch (1623:7): [True: 104k, False: 14.7k]
  ------------------
 1624|   104k|    auto func_type = std::make_unique<FuncType>(name);
 1625|   104k|    BindingHash bindings;
 1626|   104k|    CHECK_RESULT(ParseFuncSignature(&func_type->sig, &bindings));
  ------------------
  |  |   55|   104k|  do {                              \
  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 466, False: 104k]
  |  |  ------------------
  |  |   57|    466|      return ::wabt::Result::Error; \
  |  |   58|    466|    }                               \
  |  |   59|   104k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1627|   104k|    CHECK_RESULT(ErrorIfLpar({"param", "result"}));
  ------------------
  |  |   55|   104k|  do {                              \
  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 613, False: 103k]
  |  |  ------------------
  |  |   57|    613|      return ::wabt::Result::Error; \
  |  |   58|    613|    }                               \
  |  |   59|   104k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1628|   103k|    field->type = std::move(func_type);
 1629|   103k|  } else if (Match(TokenType::Struct)) {
  ------------------
  |  Branch (1629:14): [True: 0, False: 14.7k]
  ------------------
 1630|      0|    if (!options_->features.gc_enabled()) {
  ------------------
  |  Branch (1630:9): [True: 0, False: 0]
  ------------------
 1631|      0|      Error(loc, "struct not allowed");
 1632|      0|      return Result::Error;
 1633|      0|    }
 1634|      0|    auto struct_type = std::make_unique<StructType>(name);
 1635|      0|    CHECK_RESULT(ParseFieldList(&struct_type->fields));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1636|      0|    field->type = std::move(struct_type);
 1637|  14.7k|  } else if (Match(TokenType::Array)) {
  ------------------
  |  Branch (1637:14): [True: 3.13k, False: 11.5k]
  ------------------
 1638|  3.13k|    if (!options_->features.gc_enabled()) {
  ------------------
  |  Branch (1638:9): [True: 3.13k, False: 0]
  ------------------
 1639|  3.13k|      Error(loc, "array type not allowed");
 1640|  3.13k|    }
 1641|  3.13k|    auto array_type = std::make_unique<ArrayType>(name);
 1642|  3.13k|    CHECK_RESULT(ParseField(&array_type->field));
  ------------------
  |  |   55|  3.13k|  do {                              \
  |  |   56|  3.13k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.26k, False: 869]
  |  |  ------------------
  |  |   57|  2.26k|      return ::wabt::Result::Error; \
  |  |   58|  2.26k|    }                               \
  |  |   59|  3.13k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1643|    869|    field->type = std::move(array_type);
 1644|  11.5k|  } else {
 1645|  11.5k|    return ErrorExpected({"func", "struct", "array"});
 1646|  11.5k|  }
 1647|       |
 1648|   104k|  EXPECT(Rpar);
  ------------------
  |  |   31|   104k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   104k|  do {                              \
  |  |  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 5.96k, False: 98.3k]
  |  |  |  |  ------------------
  |  |  |  |   57|  5.96k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  5.96k|    }                               \
  |  |  |  |   59|   104k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1649|  98.3k|  EXPECT(Rpar);
  ------------------
  |  |   31|  98.3k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  98.3k|  do {                              \
  |  |  |  |   56|  98.3k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 550, False: 97.8k]
  |  |  |  |  ------------------
  |  |  |  |   57|    550|      return ::wabt::Result::Error; \
  |  |  |  |   58|    550|    }                               \
  |  |  |  |   59|  98.3k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1650|  97.8k|  module->AppendField(std::move(field));
 1651|  97.8k|  return Result::Ok;
 1652|  98.3k|}
_ZN4wabt10WastParser10ParseFieldEPNS_5FieldE:
 1654|  3.13k|Result WastParser::ParseField(Field* field) {
 1655|  3.13k|  WABT_TRACE(ParseField);
 1656|  3.13k|  auto parse_mut_valuetype = [&]() -> Result {
 1657|       |    // TODO: Share with ParseGlobalType?
 1658|  3.13k|    if (MatchLpar(TokenType::Mut)) {
 1659|  3.13k|      field->mutable_ = true;
 1660|  3.13k|      Var type;
 1661|  3.13k|      CHECK_RESULT(ParseValueType(&type));
 1662|  3.13k|      field->type = Type(type.index());
 1663|  3.13k|      EXPECT(Rpar);
 1664|  3.13k|    } else {
 1665|  3.13k|      field->mutable_ = false;
 1666|  3.13k|      Var type;
 1667|  3.13k|      CHECK_RESULT(ParseValueType(&type));
 1668|  3.13k|      field->type = Type(type.index());
 1669|  3.13k|    }
 1670|  3.13k|    return Result::Ok;
 1671|  3.13k|  };
 1672|       |
 1673|  3.13k|  if (MatchLpar(TokenType::Field)) {
  ------------------
  |  Branch (1673:7): [True: 1.74k, False: 1.38k]
  ------------------
 1674|  1.74k|    ParseBindVarOpt(&field->name);
 1675|  1.74k|    CHECK_RESULT(parse_mut_valuetype());
  ------------------
  |  |   55|  1.74k|  do {                              \
  |  |   56|  1.74k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.36k, False: 388]
  |  |  ------------------
  |  |   57|  1.36k|      return ::wabt::Result::Error; \
  |  |   58|  1.36k|    }                               \
  |  |   59|  1.74k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1676|    388|    EXPECT(Rpar);
  ------------------
  |  |   31|    388|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    388|  do {                              \
  |  |  |  |   56|    388|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 194, False: 194]
  |  |  |  |  ------------------
  |  |  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |  |  |   58|    194|    }                               \
  |  |  |  |   59|    388|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1677|  1.38k|  } else {
 1678|  1.38k|    CHECK_RESULT(parse_mut_valuetype());
  ------------------
  |  |   55|  1.38k|  do {                              \
  |  |   56|  1.38k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 714, False: 675]
  |  |  ------------------
  |  |   57|    714|      return ::wabt::Result::Error; \
  |  |   58|    714|    }                               \
  |  |   59|  1.38k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1679|  1.38k|  }
 1680|       |
 1681|    869|  return Result::Ok;
 1682|  3.13k|}
_ZN4wabt10WastParser22ParseGlobalModuleFieldEPNS_6ModuleE:
 1694|   521k|Result WastParser::ParseGlobalModuleField(Module* module) {
 1695|   521k|  WABT_TRACE(ParseGlobalModuleField);
 1696|   521k|  EXPECT(Lpar);
  ------------------
  |  |   31|   521k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   521k|  do {                              \
  |  |  |  |   56|   521k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 521k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   521k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1697|   521k|  Location loc = GetLocation();
 1698|   521k|  EXPECT(Global);
  ------------------
  |  |   31|   521k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   521k|  do {                              \
  |  |  |  |   56|   521k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 521k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   521k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1699|   521k|  std::string name;
 1700|   521k|  ParseBindVarOpt(&name);
 1701|       |
 1702|   521k|  ModuleFieldList export_fields;
 1703|   521k|  CHECK_RESULT(ParseInlineExports(&export_fields, ExternalKind::Global));
  ------------------
  |  |   55|   521k|  do {                              \
  |  |   56|   521k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 221, False: 521k]
  |  |  ------------------
  |  |   57|    221|      return ::wabt::Result::Error; \
  |  |   58|    221|    }                               \
  |  |   59|   521k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1704|       |
 1705|   521k|  if (PeekMatchLpar(TokenType::Import)) {
  ------------------
  |  Branch (1705:7): [True: 104k, False: 416k]
  ------------------
 1706|   104k|    CheckImportOrdering(module);
 1707|   104k|    auto import = std::make_unique<GlobalImport>(name);
 1708|   104k|    CHECK_RESULT(ParseInlineImport(import.get()));
  ------------------
  |  |   55|   104k|  do {                              \
  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 78.7k, False: 26.2k]
  |  |  ------------------
  |  |   57|  78.7k|      return ::wabt::Result::Error; \
  |  |   58|  78.7k|    }                               \
  |  |   59|   104k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1709|  26.2k|    CHECK_RESULT(ParseGlobalType(&import->global));
  ------------------
  |  |   55|  26.2k|  do {                              \
  |  |   56|  26.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 362, False: 25.8k]
  |  |  ------------------
  |  |   57|    362|      return ::wabt::Result::Error; \
  |  |   58|    362|    }                               \
  |  |   59|  26.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1710|  25.8k|    auto field =
 1711|  25.8k|        std::make_unique<ImportModuleField>(std::move(import), GetLocation());
 1712|  25.8k|    module->AppendField(std::move(field));
 1713|   416k|  } else {
 1714|   416k|    auto field = std::make_unique<GlobalModuleField>(loc, name);
 1715|   416k|    CHECK_RESULT(ParseGlobalType(&field->global));
  ------------------
  |  |   55|   416k|  do {                              \
  |  |   56|   416k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 40.4k, False: 376k]
  |  |  ------------------
  |  |   57|  40.4k|      return ::wabt::Result::Error; \
  |  |   58|  40.4k|    }                               \
  |  |   59|   416k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1716|   376k|    CHECK_RESULT(ParseTerminatingInstrList(&field->global.init_expr));
  ------------------
  |  |   55|   376k|  do {                              \
  |  |   56|   376k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.68k, False: 373k]
  |  |  ------------------
  |  |   57|  2.68k|      return ::wabt::Result::Error; \
  |  |   58|  2.68k|    }                               \
  |  |   59|   376k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1717|   373k|    module->AppendField(std::move(field));
 1718|   373k|  }
 1719|       |
 1720|   399k|  AppendInlineExportFields(module, &export_fields, module->globals.size() - 1);
 1721|       |
 1722|   399k|  EXPECT(Rpar);
  ------------------
  |  |   31|   399k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   399k|  do {                              \
  |  |  |  |   56|   399k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 328k, False: 70.9k]
  |  |  |  |  ------------------
  |  |  |  |   57|   328k|      return ::wabt::Result::Error; \
  |  |  |  |   58|   328k|    }                               \
  |  |  |  |   59|   399k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1723|  70.9k|  return Result::Ok;
 1724|   399k|}
_ZN4wabt10WastParser22ParseImportModuleFieldEPNS_6ModuleE:
 1726|   150k|Result WastParser::ParseImportModuleField(Module* module) {
 1727|   150k|  WABT_TRACE(ParseImportModuleField);
 1728|   150k|  EXPECT(Lpar);
  ------------------
  |  |   31|   150k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   150k|  do {                              \
  |  |  |  |   56|   150k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 150k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   150k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1729|   150k|  Location loc = GetLocation();
 1730|   150k|  CheckImportOrdering(module);
 1731|   150k|  EXPECT(Import);
  ------------------
  |  |   31|   150k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   150k|  do {                              \
  |  |  |  |   56|   150k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 150k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   150k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1732|   150k|  std::string module_name;
 1733|   150k|  std::string field_name;
 1734|   150k|  CHECK_RESULT(ParseQuotedText(&module_name));
  ------------------
  |  |   55|   150k|  do {                              \
  |  |   56|   150k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 57.8k, False: 92.3k]
  |  |  ------------------
  |  |   57|  57.8k|      return ::wabt::Result::Error; \
  |  |   58|  57.8k|    }                               \
  |  |   59|   150k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1735|  92.3k|  CHECK_RESULT(ParseQuotedText(&field_name));
  ------------------
  |  |   55|  92.3k|  do {                              \
  |  |   56|  92.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 4.25k, False: 88.0k]
  |  |  ------------------
  |  |   57|  4.25k|      return ::wabt::Result::Error; \
  |  |   58|  4.25k|    }                               \
  |  |   59|  92.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1736|  88.0k|  EXPECT(Lpar);
  ------------------
  |  |   31|  88.0k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  88.0k|  do {                              \
  |  |  |  |   56|  88.0k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 6.04k, False: 82.0k]
  |  |  |  |  ------------------
  |  |  |  |   57|  6.04k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  6.04k|    }                               \
  |  |  |  |   59|  88.0k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1737|       |
 1738|  82.0k|  std::unique_ptr<ImportModuleField> field;
 1739|  82.0k|  std::string name;
 1740|       |
 1741|  82.0k|  switch (Peek()) {
 1742|  1.92k|    case TokenType::Func: {
  ------------------
  |  Branch (1742:5): [True: 1.92k, False: 80.1k]
  ------------------
 1743|  1.92k|      Consume();
 1744|  1.92k|      ParseBindVarOpt(&name);
 1745|  1.92k|      auto import = std::make_unique<FuncImport>(name);
 1746|  1.92k|      CHECK_RESULT(ParseTypeUseOpt(&import->func.decl));
  ------------------
  |  |   55|  1.92k|  do {                              \
  |  |   56|  1.92k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 194, False: 1.73k]
  |  |  ------------------
  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |   58|    194|    }                               \
  |  |   59|  1.92k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1747|  1.73k|      CHECK_RESULT(
  ------------------
  |  |   55|  1.73k|  do {                              \
  |  |   56|  1.73k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 194, False: 1.53k]
  |  |  ------------------
  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |   58|    194|    }                               \
  |  |   59|  1.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1748|  1.73k|          ParseFuncSignature(&import->func.decl.sig, &import->func.bindings));
 1749|  1.53k|      CHECK_RESULT(ErrorIfLpar({"param", "result"}));
  ------------------
  |  |   55|  1.53k|  do {                              \
  |  |   56|  1.53k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 384, False: 1.15k]
  |  |  ------------------
  |  |   57|    384|      return ::wabt::Result::Error; \
  |  |   58|    384|    }                               \
  |  |   59|  1.53k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1750|  1.15k|      EXPECT(Rpar);
  ------------------
  |  |   31|  1.15k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.15k|  do {                              \
  |  |  |  |   56|  1.15k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 889, False: 265]
  |  |  |  |  ------------------
  |  |  |  |   57|    889|      return ::wabt::Result::Error; \
  |  |  |  |   58|    889|    }                               \
  |  |  |  |   59|  1.15k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1751|    265|      field = std::make_unique<ImportModuleField>(std::move(import), loc);
 1752|    265|      break;
 1753|  1.15k|    }
 1754|       |
 1755|  4.33k|    case TokenType::Table: {
  ------------------
  |  Branch (1755:5): [True: 4.33k, False: 77.7k]
  ------------------
 1756|  4.33k|      Consume();
 1757|  4.33k|      ParseBindVarOpt(&name);
 1758|  4.33k|      auto import = std::make_unique<TableImport>(name);
 1759|  4.33k|      CHECK_RESULT(ParseLimitsIndex(&import->table.elem_limits));
  ------------------
  |  |   55|  4.33k|  do {                              \
  |  |   56|  4.33k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 4.33k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  4.33k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1760|  4.33k|      CHECK_RESULT(ParseLimits(&import->table.elem_limits));
  ------------------
  |  |   55|  4.33k|  do {                              \
  |  |   56|  4.33k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.55k, False: 2.78k]
  |  |  ------------------
  |  |   57|  1.55k|      return ::wabt::Result::Error; \
  |  |   58|  1.55k|    }                               \
  |  |   59|  4.33k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1761|  2.78k|      CHECK_RESULT(ParseRefType(&import->table.elem_type));
  ------------------
  |  |   55|  2.78k|  do {                              \
  |  |   56|  2.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 316, False: 2.47k]
  |  |  ------------------
  |  |   57|    316|      return ::wabt::Result::Error; \
  |  |   58|    316|    }                               \
  |  |   59|  2.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1762|  2.47k|      EXPECT(Rpar);
  ------------------
  |  |   31|  2.47k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  2.47k|  do {                              \
  |  |  |  |   56|  2.47k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 2.24k, False: 225]
  |  |  |  |  ------------------
  |  |  |  |   57|  2.24k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  2.24k|    }                               \
  |  |  |  |   59|  2.47k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1763|    225|      field = std::make_unique<ImportModuleField>(std::move(import), loc);
 1764|    225|      break;
 1765|  2.47k|    }
 1766|       |
 1767|  2.78k|    case TokenType::Memory: {
  ------------------
  |  Branch (1767:5): [True: 2.78k, False: 79.2k]
  ------------------
 1768|  2.78k|      Consume();
 1769|  2.78k|      ParseBindVarOpt(&name);
 1770|  2.78k|      auto import = std::make_unique<MemoryImport>(name);
 1771|  2.78k|      import->memory.page_size = WABT_DEFAULT_PAGE_SIZE;
  ------------------
  |  |   47|  2.78k|#define WABT_DEFAULT_PAGE_SIZE 0x10000
  ------------------
 1772|  2.78k|      CHECK_RESULT(ParseLimitsIndex(&import->memory.page_limits));
  ------------------
  |  |   55|  2.78k|  do {                              \
  |  |   56|  2.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.78k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1773|  2.78k|      CHECK_RESULT(ParseLimits(&import->memory.page_limits));
  ------------------
  |  |   55|  2.78k|  do {                              \
  |  |   56|  2.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.35k, False: 429]
  |  |  ------------------
  |  |   57|  2.35k|      return ::wabt::Result::Error; \
  |  |   58|  2.35k|    }                               \
  |  |   59|  2.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1774|    429|      CHECK_RESULT(ParsePageSize(&import->memory.page_size));
  ------------------
  |  |   55|    429|  do {                              \
  |  |   56|    429|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 429]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    429|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1775|    429|      EXPECT(Rpar);
  ------------------
  |  |   31|    429|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    429|  do {                              \
  |  |  |  |   56|    429|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 235, False: 194]
  |  |  |  |  ------------------
  |  |  |  |   57|    235|      return ::wabt::Result::Error; \
  |  |  |  |   58|    235|    }                               \
  |  |  |  |   59|    429|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1776|    194|      field = std::make_unique<ImportModuleField>(std::move(import), loc);
 1777|    194|      break;
 1778|    429|    }
 1779|       |
 1780|  3.95k|    case TokenType::Global: {
  ------------------
  |  Branch (1780:5): [True: 3.95k, False: 78.0k]
  ------------------
 1781|  3.95k|      Consume();
 1782|  3.95k|      ParseBindVarOpt(&name);
 1783|  3.95k|      auto import = std::make_unique<GlobalImport>(name);
 1784|  3.95k|      CHECK_RESULT(ParseGlobalType(&import->global));
  ------------------
  |  |   55|  3.95k|  do {                              \
  |  |   56|  3.95k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.17k, False: 785]
  |  |  ------------------
  |  |   57|  3.17k|      return ::wabt::Result::Error; \
  |  |   58|  3.17k|    }                               \
  |  |   59|  3.95k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1785|    785|      EXPECT(Rpar);
  ------------------
  |  |   31|    785|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    785|  do {                              \
  |  |  |  |   56|    785|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 352, False: 433]
  |  |  |  |  ------------------
  |  |  |  |   57|    352|      return ::wabt::Result::Error; \
  |  |  |  |   58|    352|    }                               \
  |  |  |  |   59|    785|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1786|    433|      field = std::make_unique<ImportModuleField>(std::move(import), loc);
 1787|    433|      break;
 1788|    785|    }
 1789|       |
 1790|  65.9k|    case TokenType::Tag: {
  ------------------
  |  Branch (1790:5): [True: 65.9k, False: 16.0k]
  ------------------
 1791|  65.9k|      Consume();
 1792|  65.9k|      ParseBindVarOpt(&name);
 1793|  65.9k|      auto import = std::make_unique<TagImport>(name);
 1794|  65.9k|      CHECK_RESULT(ParseTypeUseOpt(&import->tag.decl));
  ------------------
  |  |   55|  65.9k|  do {                              \
  |  |   56|  65.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 202, False: 65.7k]
  |  |  ------------------
  |  |   57|    202|      return ::wabt::Result::Error; \
  |  |   58|    202|    }                               \
  |  |   59|  65.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1795|  65.7k|      CHECK_RESULT(ParseUnboundFuncSignature(&import->tag.decl.sig));
  ------------------
  |  |   55|  65.7k|  do {                              \
  |  |   56|  65.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 255, False: 65.5k]
  |  |  ------------------
  |  |   57|    255|      return ::wabt::Result::Error; \
  |  |   58|    255|    }                               \
  |  |   59|  65.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1796|  65.5k|      EXPECT(Rpar);
  ------------------
  |  |   31|  65.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  65.5k|  do {                              \
  |  |  |  |   56|  65.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 1.59k, False: 63.9k]
  |  |  |  |  ------------------
  |  |  |  |   57|  1.59k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  1.59k|    }                               \
  |  |  |  |   59|  65.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1797|  63.9k|      field = std::make_unique<ImportModuleField>(std::move(import), loc);
 1798|  63.9k|      break;
 1799|  65.5k|    }
 1800|       |
 1801|  3.04k|    default:
  ------------------
  |  Branch (1801:5): [True: 3.04k, False: 79.0k]
  ------------------
 1802|  3.04k|      return ErrorExpected({"an external kind"});
 1803|  82.0k|  }
 1804|       |
 1805|  65.0k|  field->import->module_name = module_name;
 1806|  65.0k|  field->import->field_name = field_name;
 1807|       |
 1808|  65.0k|  module->AppendField(std::move(field));
 1809|  65.0k|  EXPECT(Rpar);
  ------------------
  |  |   31|  65.0k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  65.0k|  do {                              \
  |  |  |  |   56|  65.0k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 10.7k, False: 54.2k]
  |  |  |  |  ------------------
  |  |  |  |   57|  10.7k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  10.7k|    }                               \
  |  |  |  |   59|  65.0k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1810|  54.2k|  return Result::Ok;
 1811|  65.0k|}
_ZN4wabt10WastParser22ParseMemoryModuleFieldEPNS_6ModuleE:
 1813|   552k|Result WastParser::ParseMemoryModuleField(Module* module) {
 1814|   552k|  WABT_TRACE(ParseMemoryModuleField);
 1815|   552k|  EXPECT(Lpar);
  ------------------
  |  |   31|   552k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   552k|  do {                              \
  |  |  |  |   56|   552k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 552k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   552k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1816|   552k|  Location loc = GetLocation();
 1817|   552k|  EXPECT(Memory);
  ------------------
  |  |   31|   552k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   552k|  do {                              \
  |  |  |  |   56|   552k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 552k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   552k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1818|   552k|  std::string name;
 1819|   552k|  ParseBindVarOpt(&name);
 1820|       |
 1821|   552k|  ModuleFieldList export_fields;
 1822|   552k|  CHECK_RESULT(ParseInlineExports(&export_fields, ExternalKind::Memory));
  ------------------
  |  |   55|   552k|  do {                              \
  |  |   56|   552k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 493, False: 551k]
  |  |  ------------------
  |  |   57|    493|      return ::wabt::Result::Error; \
  |  |   58|    493|    }                               \
  |  |   59|   552k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1823|       |
 1824|   551k|  if (PeekMatchLpar(TokenType::Import)) {
  ------------------
  |  Branch (1824:7): [True: 3.16k, False: 548k]
  ------------------
 1825|  3.16k|    CheckImportOrdering(module);
 1826|  3.16k|    auto import = std::make_unique<MemoryImport>(name);
 1827|  3.16k|    import->memory.page_size = WABT_DEFAULT_PAGE_SIZE;
  ------------------
  |  |   47|  3.16k|#define WABT_DEFAULT_PAGE_SIZE 0x10000
  ------------------
 1828|  3.16k|    CHECK_RESULT(ParseInlineImport(import.get()));
  ------------------
  |  |   55|  3.16k|  do {                              \
  |  |   56|  3.16k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.45k, False: 707]
  |  |  ------------------
  |  |   57|  2.45k|      return ::wabt::Result::Error; \
  |  |   58|  2.45k|    }                               \
  |  |   59|  3.16k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1829|    707|    CHECK_RESULT(ParseLimitsIndex(&import->memory.page_limits));
  ------------------
  |  |   55|    707|  do {                              \
  |  |   56|    707|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 707]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    707|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1830|    707|    CHECK_RESULT(ParseLimits(&import->memory.page_limits));
  ------------------
  |  |   55|    707|  do {                              \
  |  |   56|    707|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 203, False: 504]
  |  |  ------------------
  |  |   57|    203|      return ::wabt::Result::Error; \
  |  |   58|    203|    }                               \
  |  |   59|    707|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1831|    504|    CHECK_RESULT(ParsePageSize(&import->memory.page_size));
  ------------------
  |  |   55|    504|  do {                              \
  |  |   56|    504|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 504]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    504|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1832|    504|    auto field =
 1833|    504|        std::make_unique<ImportModuleField>(std::move(import), GetLocation());
 1834|    504|    module->AppendField(std::move(field));
 1835|   548k|  } else {
 1836|   548k|    auto field = std::make_unique<MemoryModuleField>(loc, name);
 1837|   548k|    field->memory.page_size = WABT_DEFAULT_PAGE_SIZE;
  ------------------
  |  |   47|   548k|#define WABT_DEFAULT_PAGE_SIZE 0x10000
  ------------------
 1838|   548k|    CHECK_RESULT(ParseLimitsIndex(&field->memory.page_limits));
  ------------------
  |  |   55|   548k|  do {                              \
  |  |   56|   548k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 548k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|   548k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1839|   548k|    if (PeekMatchLpar(TokenType::PageSize)) {
  ------------------
  |  Branch (1839:9): [True: 0, False: 548k]
  ------------------
 1840|       |      // this is the data abbreviation (no limits)
 1841|      0|      CHECK_RESULT(ParsePageSize(&field->memory.page_size));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1842|      0|      if (!PeekMatchLpar(TokenType::Data)) {
  ------------------
  |  Branch (1842:11): [True: 0, False: 0]
  ------------------
 1843|      0|        ConsumeIfLpar();
 1844|      0|        return ErrorExpected({"inline data segment"});
 1845|      0|      }
 1846|      0|    }
 1847|   548k|    if (MatchLpar(TokenType::Data)) {
  ------------------
  |  Branch (1847:9): [True: 973, False: 547k]
  ------------------
 1848|    973|      auto data_segment_field = std::make_unique<DataSegmentModuleField>(loc);
 1849|    973|      DataSegment& data_segment = data_segment_field->data_segment;
 1850|    973|      data_segment.memory_var = Var(module->memories.size(), GetLocation());
 1851|    973|      data_segment.offset.push_back(std::make_unique<ConstExpr>(
 1852|    973|          field->memory.page_limits.is_64 ? Const::I64(0) : Const::I32(0)));
  ------------------
  |  Branch (1852:11): [True: 213, False: 760]
  ------------------
 1853|    973|      data_segment.offset.back().loc = loc;
 1854|    973|      ParseTextListOpt(&data_segment.data);
 1855|    973|      EXPECT(Rpar);
  ------------------
  |  |   31|    973|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    973|  do {                              \
  |  |  |  |   56|    973|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 410, False: 563]
  |  |  |  |  ------------------
  |  |  |  |   57|    410|      return ::wabt::Result::Error; \
  |  |  |  |   58|    410|    }                               \
  |  |  |  |   59|    973|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1856|       |
 1857|    563|      uint32_t num_pages = WABT_BYTES_TO_MIN_PAGES(data_segment.data.size(),
 1858|    563|                                                   field->memory.page_size);
 1859|    563|      field->memory.page_limits.initial = num_pages;
 1860|    563|      field->memory.page_limits.max = num_pages;
 1861|    563|      field->memory.page_limits.has_max = true;
 1862|       |
 1863|    563|      module->AppendField(std::move(field));
 1864|    563|      module->AppendField(std::move(data_segment_field));
 1865|   547k|    } else {
 1866|   547k|      CHECK_RESULT(ParseLimits(&field->memory.page_limits));
  ------------------
  |  |   55|   547k|  do {                              \
  |  |   56|   547k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 14.4k, False: 533k]
  |  |  ------------------
  |  |   57|  14.4k|      return ::wabt::Result::Error; \
  |  |   58|  14.4k|    }                               \
  |  |   59|   547k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1867|   533k|      CHECK_RESULT(ParsePageSize(&field->memory.page_size));
  ------------------
  |  |   55|   533k|  do {                              \
  |  |   56|   533k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 533k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|   533k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1868|   533k|      module->AppendField(std::move(field));
 1869|   533k|    }
 1870|   548k|  }
 1871|       |
 1872|   534k|  AppendInlineExportFields(module, &export_fields, module->memories.size() - 1);
 1873|       |
 1874|   534k|  EXPECT(Rpar);
  ------------------
  |  |   31|   534k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   534k|  do {                              \
  |  |  |  |   56|   534k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 533k, False: 1.09k]
  |  |  |  |  ------------------
  |  |  |  |   57|   533k|      return ::wabt::Result::Error; \
  |  |  |  |   58|   533k|    }                               \
  |  |  |  |   59|   534k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1875|  1.09k|  return Result::Ok;
 1876|   534k|}
_ZN4wabt10WastParser21ParseStartModuleFieldEPNS_6ModuleE:
 1878|  1.06k|Result WastParser::ParseStartModuleField(Module* module) {
 1879|  1.06k|  WABT_TRACE(ParseStartModuleField);
 1880|  1.06k|  EXPECT(Lpar);
  ------------------
  |  |   31|  1.06k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.06k|  do {                              \
  |  |  |  |   56|  1.06k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 1.06k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  1.06k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1881|  1.06k|  Location loc = GetLocation();
 1882|  1.06k|  if (module->starts.size() > 0) {
  ------------------
  |  Branch (1882:7): [True: 519, False: 550]
  ------------------
 1883|    519|    Error(loc, "multiple start sections");
 1884|    519|    return Result::Error;
 1885|    519|  }
 1886|    550|  EXPECT(Start);
  ------------------
  |  |   31|    550|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    550|  do {                              \
  |  |  |  |   56|    550|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 550]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|    550|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1887|    550|  Var var;
 1888|    550|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|    550|  do {                              \
  |  |   56|    550|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 249, False: 301]
  |  |  ------------------
  |  |   57|    249|      return ::wabt::Result::Error; \
  |  |   58|    249|    }                               \
  |  |   59|    550|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1889|    301|  EXPECT(Rpar);
  ------------------
  |  |   31|    301|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    301|  do {                              \
  |  |  |  |   56|    301|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 222, False: 79]
  |  |  |  |  ------------------
  |  |  |  |   57|    222|      return ::wabt::Result::Error; \
  |  |  |  |   58|    222|    }                               \
  |  |  |  |   59|    301|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1890|     79|  module->AppendField(std::make_unique<StartModuleField>(var, loc));
 1891|     79|  return Result::Ok;
 1892|    301|}
_ZN4wabt10WastParser21ParseTableModuleFieldEPNS_6ModuleE:
 1894|   170k|Result WastParser::ParseTableModuleField(Module* module) {
 1895|   170k|  WABT_TRACE(ParseTableModuleField);
 1896|   170k|  EXPECT(Lpar);
  ------------------
  |  |   31|   170k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   170k|  do {                              \
  |  |  |  |   56|   170k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 170k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   170k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1897|   170k|  Location loc = GetLocation();
 1898|   170k|  EXPECT(Table);
  ------------------
  |  |   31|   170k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   170k|  do {                              \
  |  |  |  |   56|   170k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 170k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   170k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1899|   170k|  std::string name;
 1900|   170k|  ParseBindVarOpt(&name);
 1901|       |
 1902|   170k|  ModuleFieldList export_fields;
 1903|   170k|  CHECK_RESULT(ParseInlineExports(&export_fields, ExternalKind::Table));
  ------------------
  |  |   55|   170k|  do {                              \
  |  |   56|   170k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 230, False: 170k]
  |  |  ------------------
  |  |   57|    230|      return ::wabt::Result::Error; \
  |  |   58|    230|    }                               \
  |  |   59|   170k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1904|       |
 1905|   170k|  if (PeekMatchLpar(TokenType::Import)) {
  ------------------
  |  Branch (1905:7): [True: 24.7k, False: 145k]
  ------------------
 1906|  24.7k|    CheckImportOrdering(module);
 1907|  24.7k|    auto import = std::make_unique<TableImport>(name);
 1908|  24.7k|    CHECK_RESULT(ParseInlineImport(import.get()));
  ------------------
  |  |   55|  24.7k|  do {                              \
  |  |   56|  24.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 6.83k, False: 17.9k]
  |  |  ------------------
  |  |   57|  6.83k|      return ::wabt::Result::Error; \
  |  |   58|  6.83k|    }                               \
  |  |   59|  24.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1909|  17.9k|    CHECK_RESULT(ParseLimitsIndex(&import->table.elem_limits));
  ------------------
  |  |   55|  17.9k|  do {                              \
  |  |   56|  17.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 17.9k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  17.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1910|  17.9k|    CHECK_RESULT(ParseLimits(&import->table.elem_limits));
  ------------------
  |  |   55|  17.9k|  do {                              \
  |  |   56|  17.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 548, False: 17.4k]
  |  |  ------------------
  |  |   57|    548|      return ::wabt::Result::Error; \
  |  |   58|    548|    }                               \
  |  |   59|  17.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1911|  17.4k|    CHECK_RESULT(ParseRefType(&import->table.elem_type));
  ------------------
  |  |   55|  17.4k|  do {                              \
  |  |   56|  17.4k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 335, False: 17.0k]
  |  |  ------------------
  |  |   57|    335|      return ::wabt::Result::Error; \
  |  |   58|    335|    }                               \
  |  |   59|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1912|  17.0k|    auto field =
 1913|  17.0k|        std::make_unique<ImportModuleField>(std::move(import), GetLocation());
 1914|  17.0k|    module->AppendField(std::move(field));
 1915|   145k|  } else {
 1916|   145k|    auto field = std::make_unique<TableModuleField>(loc, name);
 1917|   145k|    auto& table = field->table;
 1918|   145k|    CHECK_RESULT(ParseLimitsIndex(&table.elem_limits));
  ------------------
  |  |   55|   145k|  do {                              \
  |  |   56|   145k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 145k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|   145k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1919|   145k|    if (PeekMatch(TokenType::ValueType)) {
  ------------------
  |  Branch (1919:9): [True: 2.59k, False: 143k]
  ------------------
 1920|  2.59k|      Type elem_type;
 1921|  2.59k|      CHECK_RESULT(ParseRefType(&elem_type));
  ------------------
  |  |   55|  2.59k|  do {                              \
  |  |   56|  2.59k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.59k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.59k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1922|       |
 1923|  2.59k|      EXPECT(Lpar);
  ------------------
  |  |   31|  2.59k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  2.59k|  do {                              \
  |  |  |  |   56|  2.59k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 607, False: 1.99k]
  |  |  |  |  ------------------
  |  |  |  |   57|    607|      return ::wabt::Result::Error; \
  |  |  |  |   58|    607|    }                               \
  |  |  |  |   59|  2.59k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1924|  1.99k|      EXPECT(Elem);
  ------------------
  |  |   31|  1.99k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.99k|  do {                              \
  |  |  |  |   56|  1.99k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 992, False: 999]
  |  |  |  |  ------------------
  |  |  |  |   57|    992|      return ::wabt::Result::Error; \
  |  |  |  |   58|    992|    }                               \
  |  |  |  |   59|  1.99k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1925|       |
 1926|    999|      auto elem_segment_field = std::make_unique<ElemSegmentModuleField>(loc);
 1927|    999|      ElemSegment& elem_segment = elem_segment_field->elem_segment;
 1928|    999|      elem_segment.table_var = Var(module->tables.size(), GetLocation());
 1929|    999|      auto offset = table.elem_limits.is_64 ? Const::I64(0) : Const::I32(0);
  ------------------
  |  Branch (1929:21): [True: 235, False: 764]
  ------------------
 1930|    999|      elem_segment.offset.push_back(std::make_unique<ConstExpr>(offset));
 1931|    999|      elem_segment.offset.back().loc = loc;
 1932|    999|      elem_segment.elem_type = elem_type;
 1933|       |      // Syntax is either an optional list of var (legacy), or a non-empty list
 1934|       |      // of elem expr.
 1935|    999|      ExprList elem_expr;
 1936|    999|      if (ParseElemExprOpt(&elem_expr)) {
  ------------------
  |  Branch (1936:11): [True: 409, False: 590]
  ------------------
 1937|    409|        elem_segment.elem_exprs.push_back(std::move(elem_expr));
 1938|       |        // Parse the rest.
 1939|    409|        ParseElemExprListOpt(&elem_segment.elem_exprs);
 1940|    590|      } else {
 1941|    590|        ParseElemExprVarListOpt(&elem_segment.elem_exprs);
 1942|    590|      }
 1943|    999|      EXPECT(Rpar);
  ------------------
  |  |   31|    999|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    999|  do {                              \
  |  |  |  |   56|    999|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 794, False: 205]
  |  |  |  |  ------------------
  |  |  |  |   57|    794|      return ::wabt::Result::Error; \
  |  |  |  |   58|    794|    }                               \
  |  |  |  |   59|    999|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1944|       |
 1945|    205|      table.elem_limits.initial = elem_segment.elem_exprs.size();
 1946|    205|      table.elem_limits.max = elem_segment.elem_exprs.size();
 1947|    205|      table.elem_limits.has_max = true;
 1948|    205|      table.elem_type = elem_type;
 1949|    205|      module->AppendField(std::move(field));
 1950|    205|      module->AppendField(std::move(elem_segment_field));
 1951|   143k|    } else {
 1952|   143k|      CHECK_RESULT(ParseLimits(&table.elem_limits));
  ------------------
  |  |   55|   143k|  do {                              \
  |  |   56|   143k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 31.7k, False: 111k]
  |  |  ------------------
  |  |   57|  31.7k|      return ::wabt::Result::Error; \
  |  |   58|  31.7k|    }                               \
  |  |   59|   143k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1953|   111k|      CHECK_RESULT(ParseRefType(&table.elem_type));
  ------------------
  |  |   55|   111k|  do {                              \
  |  |   56|   111k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 7.80k, False: 103k]
  |  |  ------------------
  |  |   57|  7.80k|      return ::wabt::Result::Error; \
  |  |   58|  7.80k|    }                               \
  |  |   59|   111k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1954|   103k|      module->AppendField(std::move(field));
 1955|   103k|    }
 1956|   145k|  }
 1957|       |
 1958|   120k|  AppendInlineExportFields(module, &export_fields, module->tables.size() - 1);
 1959|       |
 1960|   120k|  EXPECT(Rpar);
  ------------------
  |  |   31|   120k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   120k|  do {                              \
  |  |  |  |   56|   120k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 118k, False: 2.42k]
  |  |  |  |  ------------------
  |  |  |  |   57|   118k|      return ::wabt::Result::Error; \
  |  |  |  |   58|   118k|    }                               \
  |  |  |  |   59|   120k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1961|  2.42k|  return Result::Ok;
 1962|   120k|}
_ZN4wabt10WastParser15ParseExportDescEPNS_6ExportE:
 1964|  10.7k|Result WastParser::ParseExportDesc(Export* export_) {
 1965|  10.7k|  WABT_TRACE(ParseExportDesc);
 1966|  10.7k|  EXPECT(Lpar);
  ------------------
  |  |   31|  10.7k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  10.7k|  do {                              \
  |  |  |  |   56|  10.7k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 4.49k, False: 6.20k]
  |  |  |  |  ------------------
  |  |  |  |   57|  4.49k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  4.49k|    }                               \
  |  |  |  |   59|  10.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1967|  6.20k|  switch (Peek()) {
 1968|  1.00k|    case TokenType::Func:   export_->kind = ExternalKind::Func; break;
  ------------------
  |  Branch (1968:5): [True: 1.00k, False: 5.19k]
  ------------------
 1969|    970|    case TokenType::Table:  export_->kind = ExternalKind::Table; break;
  ------------------
  |  Branch (1969:5): [True: 970, False: 5.23k]
  ------------------
 1970|    842|    case TokenType::Memory: export_->kind = ExternalKind::Memory; break;
  ------------------
  |  Branch (1970:5): [True: 842, False: 5.36k]
  ------------------
 1971|  1.28k|    case TokenType::Global: export_->kind = ExternalKind::Global; break;
  ------------------
  |  Branch (1971:5): [True: 1.28k, False: 4.91k]
  ------------------
 1972|  1.22k|    case TokenType::Tag:    export_->kind = ExternalKind::Tag; break;
  ------------------
  |  Branch (1972:5): [True: 1.22k, False: 4.97k]
  ------------------
 1973|    870|    default:
  ------------------
  |  Branch (1973:5): [True: 870, False: 5.33k]
  ------------------
 1974|    870|      return ErrorExpected({"an external kind"});
 1975|  6.20k|  }
 1976|  5.33k|  Consume();
 1977|  5.33k|  CHECK_RESULT(ParseVar(&export_->var));
  ------------------
  |  |   55|  5.33k|  do {                              \
  |  |   56|  5.33k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 652, False: 4.68k]
  |  |  ------------------
  |  |   57|    652|      return ::wabt::Result::Error; \
  |  |   58|    652|    }                               \
  |  |   59|  5.33k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1978|  4.68k|  EXPECT(Rpar);
  ------------------
  |  |   31|  4.68k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  4.68k|  do {                              \
  |  |  |  |   56|  4.68k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 378, False: 4.30k]
  |  |  |  |  ------------------
  |  |  |  |   57|    378|      return ::wabt::Result::Error; \
  |  |  |  |   58|    378|    }                               \
  |  |  |  |   59|  4.68k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1979|  4.30k|  return Result::Ok;
 1980|  4.68k|}
_ZN4wabt10WastParser18ParseInlineExportsEPNS_14intrusive_listINS_11ModuleFieldEEENS_12ExternalKindE:
 1983|  3.05M|                                      ExternalKind kind) {
 1984|  3.05M|  WABT_TRACE(ParseInlineExports);
 1985|  3.10M|  while (PeekMatchLpar(TokenType::Export)) {
  ------------------
  |  Branch (1985:10): [True: 49.1k, False: 3.05M]
  ------------------
 1986|  49.1k|    EXPECT(Lpar);
  ------------------
  |  |   31|  49.1k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  49.1k|  do {                              \
  |  |  |  |   56|  49.1k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 49.1k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  49.1k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1987|  49.1k|    auto field = std::make_unique<ExportModuleField>(GetLocation());
 1988|  49.1k|    field->export_.kind = kind;
 1989|  49.1k|    EXPECT(Export);
  ------------------
  |  |   31|  49.1k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  49.1k|  do {                              \
  |  |  |  |   56|  49.1k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 49.1k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|  49.1k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1990|  49.1k|    CHECK_RESULT(ParseQuotedText(&field->export_.name));
  ------------------
  |  |   55|  49.1k|  do {                              \
  |  |   56|  49.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.01k, False: 48.1k]
  |  |  ------------------
  |  |   57|  1.01k|      return ::wabt::Result::Error; \
  |  |   58|  1.01k|    }                               \
  |  |   59|  49.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1991|  48.1k|    EXPECT(Rpar);
  ------------------
  |  |   31|  48.1k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  48.1k|  do {                              \
  |  |  |  |   56|  48.1k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 313, False: 47.8k]
  |  |  |  |  ------------------
  |  |  |  |   57|    313|      return ::wabt::Result::Error; \
  |  |  |  |   58|    313|    }                               \
  |  |  |  |   59|  48.1k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1992|  47.8k|    fields->push_back(std::move(field));
 1993|  47.8k|  }
 1994|  3.05M|  return Result::Ok;
 1995|  3.05M|}
_ZN4wabt10WastParser17ParseInlineImportEPNS_6ImportE:
 1997|   218k|Result WastParser::ParseInlineImport(Import* import) {
 1998|   218k|  WABT_TRACE(ParseInlineImport);
 1999|   218k|  EXPECT(Lpar);
  ------------------
  |  |   31|   218k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   218k|  do {                              \
  |  |  |  |   56|   218k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 218k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   218k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2000|   218k|  EXPECT(Import);
  ------------------
  |  |   31|   218k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   218k|  do {                              \
  |  |  |  |   56|   218k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 218k]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|   218k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2001|   218k|  CHECK_RESULT(ParseQuotedText(&import->module_name));
  ------------------
  |  |   55|   218k|  do {                              \
  |  |   56|   218k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 85.4k, False: 133k]
  |  |  ------------------
  |  |   57|  85.4k|      return ::wabt::Result::Error; \
  |  |   58|  85.4k|    }                               \
  |  |   59|   218k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2002|   133k|  CHECK_RESULT(ParseQuotedText(&import->field_name));
  ------------------
  |  |   55|   133k|  do {                              \
  |  |   56|   133k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 11.1k, False: 122k]
  |  |  ------------------
  |  |   57|  11.1k|      return ::wabt::Result::Error; \
  |  |   58|  11.1k|    }                               \
  |  |   59|   133k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2003|   122k|  EXPECT(Rpar);
  ------------------
  |  |   31|   122k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   122k|  do {                              \
  |  |  |  |   56|   122k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 2.91k, False: 119k]
  |  |  |  |  ------------------
  |  |  |  |   57|  2.91k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  2.91k|    }                               \
  |  |  |  |   59|   122k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2004|   119k|  return Result::Ok;
 2005|   122k|}
_ZN4wabt10WastParser15ParseTypeUseOptEPNS_15FuncDeclarationE:
 2007|  2.18M|Result WastParser::ParseTypeUseOpt(FuncDeclaration* decl) {
 2008|  2.18M|  WABT_TRACE(ParseTypeUseOpt);
 2009|  2.18M|  if (MatchLpar(TokenType::Type)) {
  ------------------
  |  Branch (2009:7): [True: 33.7k, False: 2.15M]
  ------------------
 2010|  33.7k|    decl->has_func_type = true;
 2011|  33.7k|    CHECK_RESULT(ParseVar(&decl->type_var));
  ------------------
  |  |   55|  33.7k|  do {                              \
  |  |   56|  33.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 5.17k, False: 28.5k]
  |  |  ------------------
  |  |   57|  5.17k|      return ::wabt::Result::Error; \
  |  |   58|  5.17k|    }                               \
  |  |   59|  33.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2012|  28.5k|    EXPECT(Rpar);
  ------------------
  |  |   31|  28.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  28.5k|  do {                              \
  |  |  |  |   56|  28.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 3.65k, False: 24.9k]
  |  |  |  |  ------------------
  |  |  |  |   57|  3.65k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  3.65k|    }                               \
  |  |  |  |   59|  28.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2013|  2.15M|  } else {
 2014|  2.15M|    decl->has_func_type = false;
 2015|  2.15M|  }
 2016|  2.17M|  return Result::Ok;
 2017|  2.18M|}
_ZN4wabt10WastParser18ParseFuncSignatureEPNS_13FuncSignatureEPNS_11BindingHashE:
 2020|  1.90M|                                      BindingHash* param_bindings) {
 2021|  1.90M|  WABT_TRACE(ParseFuncSignature);
 2022|       |
 2023|  1.90M|  ResolveTypes param_references(&sig->param_types);
 2024|  1.90M|  ResolveTypes result_references(&sig->result_types);
 2025|       |
 2026|  1.90M|  CHECK_RESULT(ParseBoundValueTypeList(TokenType::Param, &sig->param_types,
  ------------------
  |  |   55|  1.90M|  do {                              \
  |  |   56|  1.90M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.12k, False: 1.90M]
  |  |  ------------------
  |  |   57|  2.12k|      return ::wabt::Result::Error; \
  |  |   58|  2.12k|    }                               \
  |  |   59|  1.90M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2027|  1.90M|                                       param_bindings, &param_references.vars));
 2028|  1.90M|  CHECK_RESULT(ParseResultList(&sig->result_types, &result_references.vars));
  ------------------
  |  |   55|  1.90M|  do {                              \
  |  |   56|  1.90M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.34k, False: 1.90M]
  |  |  ------------------
  |  |   57|  2.34k|      return ::wabt::Result::Error; \
  |  |   58|  2.34k|    }                               \
  |  |   59|  1.90M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2029|       |
 2030|  1.90M|  if (!param_references.vars.empty()) {
  ------------------
  |  Branch (2030:7): [True: 0, False: 1.90M]
  ------------------
 2031|      0|    resolve_types_.push_back(param_references);
 2032|      0|  }
 2033|       |
 2034|  1.90M|  if (!result_references.vars.empty()) {
  ------------------
  |  Branch (2034:7): [True: 0, False: 1.90M]
  ------------------
 2035|      0|    resolve_types_.push_back(result_references);
 2036|      0|  }
 2037|       |
 2038|  1.90M|  return Result::Ok;
 2039|  1.90M|}
_ZN4wabt10WastParser25ParseUnboundFuncSignatureEPNS_13FuncSignatureE:
 2041|   376k|Result WastParser::ParseUnboundFuncSignature(FuncSignature* sig) {
 2042|   376k|  WABT_TRACE(ParseUnboundFuncSignature);
 2043|       |
 2044|   376k|  ResolveTypes param_references(&sig->param_types);
 2045|   376k|  ResolveTypes result_references(&sig->result_types);
 2046|       |
 2047|   376k|  CHECK_RESULT(ParseUnboundValueTypeList(TokenType::Param, &sig->param_types,
  ------------------
  |  |   55|   376k|  do {                              \
  |  |   56|   376k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.62k, False: 374k]
  |  |  ------------------
  |  |   57|  2.62k|      return ::wabt::Result::Error; \
  |  |   58|  2.62k|    }                               \
  |  |   59|   376k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2048|   376k|                                         &param_references.vars));
 2049|   374k|  CHECK_RESULT(ParseResultList(&sig->result_types, &result_references.vars));
  ------------------
  |  |   55|   374k|  do {                              \
  |  |   56|   374k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.19k, False: 372k]
  |  |  ------------------
  |  |   57|  1.19k|      return ::wabt::Result::Error; \
  |  |   58|  1.19k|    }                               \
  |  |   59|   374k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2050|       |
 2051|   372k|  if (!param_references.vars.empty()) {
  ------------------
  |  Branch (2051:7): [True: 0, False: 372k]
  ------------------
 2052|      0|    resolve_types_.push_back(param_references);
 2053|      0|  }
 2054|       |
 2055|   372k|  if (!result_references.vars.empty()) {
  ------------------
  |  Branch (2055:7): [True: 0, False: 372k]
  ------------------
 2056|      0|    resolve_types_.push_back(result_references);
 2057|      0|  }
 2058|       |
 2059|   372k|  return Result::Ok;
 2060|   374k|}
_ZN4wabt10WastParser23ParseBoundValueTypeListENS_9TokenTypeEPNSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEEPNS_11BindingHashEPNS3_INS0_12ReferenceVarENS5_ISB_EEEEj:
 2066|  3.62M|                                           Index binding_index_offset) {
 2067|  3.62M|  WABT_TRACE(ParseBoundValueTypeList);
 2068|  3.66M|  while (MatchLpar(token)) {
  ------------------
  |  Branch (2068:10): [True: 44.9k, False: 3.62M]
  ------------------
 2069|  44.9k|    if (PeekMatch(TokenType::Var)) {
  ------------------
  |  Branch (2069:9): [True: 30.3k, False: 14.5k]
  ------------------
 2070|  30.3k|      std::string name;
 2071|  30.3k|      Var type;
 2072|  30.3k|      Location loc = GetLocation();
 2073|  30.3k|      ParseBindVarOpt(&name);
 2074|  30.3k|      CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|  30.3k|  do {                              \
  |  |   56|  30.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 931, False: 29.4k]
  |  |  ------------------
  |  |   57|    931|      return ::wabt::Result::Error; \
  |  |   58|    931|    }                               \
  |  |   59|  30.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2075|  29.4k|      bindings->emplace(name,
 2076|  29.4k|                        Binding(loc, binding_index_offset + types->size()));
 2077|  29.4k|      if (type.is_index()) {
  ------------------
  |  Branch (2077:11): [True: 29.4k, False: 0]
  ------------------
 2078|  29.4k|        if (IsIndexLikelyType(type.index())) {
  ------------------
  |  Branch (2078:13): [True: 29.4k, False: 0]
  ------------------
 2079|  29.4k|          types->push_back(Type(type.index()));
 2080|  29.4k|        } else {
 2081|      0|          type_vars->push_back(ReferenceVar(types->size(), type));
 2082|      0|          types->push_back(Type(Type::Reference, type.index()));
 2083|      0|        }
 2084|  29.4k|      } else {
 2085|      0|        assert(type.is_name());
 2086|      0|        assert(options_->features.function_references_enabled());
 2087|      0|        type_vars->push_back(ReferenceVar(types->size(), type));
 2088|      0|        types->push_back(Type(Type::Reference, kInvalidIndex));
 2089|      0|      }
 2090|  29.4k|    } else {
 2091|  14.5k|      CHECK_RESULT(ParseValueTypeList(types, type_vars));
  ------------------
  |  |   55|  14.5k|  do {                              \
  |  |   56|  14.5k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 194, False: 14.3k]
  |  |  ------------------
  |  |   57|    194|      return ::wabt::Result::Error; \
  |  |   58|    194|    }                               \
  |  |   59|  14.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2092|  14.5k|    }
 2093|  43.7k|    EXPECT(Rpar);
  ------------------
  |  |   31|  43.7k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  43.7k|  do {                              \
  |  |  |  |   56|  43.7k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 2.59k, False: 41.1k]
  |  |  |  |  ------------------
  |  |  |  |   57|  2.59k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  2.59k|    }                               \
  |  |  |  |   59|  43.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2094|  43.7k|  }
 2095|  3.62M|  return Result::Ok;
 2096|  3.62M|}
_ZN4wabt10WastParser25ParseUnboundValueTypeListENS_9TokenTypeEPNSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEEPNS3_INS0_12ReferenceVarENS5_IS9_EEEE:
 2100|  2.65M|                                             ReferenceVars* type_vars) {
 2101|  2.65M|  WABT_TRACE(ParseUnboundValueTypeList);
 2102|  2.66M|  while (MatchLpar(token)) {
  ------------------
  |  Branch (2102:10): [True: 12.7k, False: 2.64M]
  ------------------
 2103|  12.7k|    CHECK_RESULT(ParseValueTypeList(types, type_vars));
  ------------------
  |  |   55|  12.7k|  do {                              \
  |  |   56|  12.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 788, False: 11.9k]
  |  |  ------------------
  |  |   57|    788|      return ::wabt::Result::Error; \
  |  |   58|    788|    }                               \
  |  |   59|  12.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2104|  11.9k|    EXPECT(Rpar);
  ------------------
  |  |   31|  11.9k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  11.9k|  do {                              \
  |  |  |  |   56|  11.9k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 5.78k, False: 6.19k]
  |  |  |  |  ------------------
  |  |  |  |   57|  5.78k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  5.78k|    }                               \
  |  |  |  |   59|  11.9k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2105|  11.9k|  }
 2106|  2.64M|  return Result::Ok;
 2107|  2.65M|}
_ZN4wabt10WastParser15ParseResultListEPNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEEPNS2_INS0_12ReferenceVarENS4_IS8_EEEE:
 2110|  2.27M|                                   ReferenceVars* type_vars) {
 2111|  2.27M|  WABT_TRACE(ParseResultList);
 2112|  2.27M|  return ParseUnboundValueTypeList(TokenType::Result, result_types, type_vars);
 2113|  2.27M|}
_ZN4wabt10WastParser14ParseInstrListEPNS_14intrusive_listINS_4ExprEEE:
 2115|  2.38M|Result WastParser::ParseInstrList(ExprList* exprs) {
 2116|  2.38M|  WABT_TRACE(ParseInstrList);
 2117|  2.38M|  ExprList new_exprs;
 2118|  2.84M|  while (true) {
  ------------------
  |  Branch (2118:10): [Folded - Ignored]
  ------------------
 2119|  2.84M|    auto pair = PeekPair();
 2120|  2.84M|    if (IsInstr(pair)) {
  ------------------
  |  Branch (2120:9): [True: 604k, False: 2.24M]
  ------------------
 2121|   604k|      if (Succeeded(ParseInstr(&new_exprs))) {
  ------------------
  |  Branch (2121:11): [True: 198k, False: 405k]
  ------------------
 2122|   198k|        exprs->splice(exprs->end(), new_exprs);
 2123|   405k|      } else {
 2124|   405k|        CHECK_RESULT(Synchronize(IsInstr));
  ------------------
  |  |   55|   405k|  do {                              \
  |  |   56|   405k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 148k, False: 256k]
  |  |  ------------------
  |  |   57|   148k|      return ::wabt::Result::Error; \
  |  |   58|   148k|    }                               \
  |  |   59|   405k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2125|   405k|      }
 2126|  2.24M|    } else if (IsLparAnn(pair)) {
  ------------------
  |  Branch (2126:16): [True: 6.86k, False: 2.23M]
  ------------------
 2127|  6.86k|      if (Succeeded(ParseCodeMetadataAnnotation(&new_exprs))) {
  ------------------
  |  Branch (2127:11): [True: 4.49k, False: 2.36k]
  ------------------
 2128|  4.49k|        exprs->splice(exprs->end(), new_exprs);
 2129|  4.49k|      } else {
 2130|  2.36k|        CHECK_RESULT(Synchronize(IsLparAnn));
  ------------------
  |  |   55|  2.36k|  do {                              \
  |  |   56|  2.36k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.36k, False: 0]
  |  |  ------------------
  |  |   57|  2.36k|      return ::wabt::Result::Error; \
  |  |   58|  2.36k|    }                               \
  |  |   59|  2.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2131|  2.36k|      }
 2132|  2.23M|    } else {
 2133|  2.23M|      break;
 2134|  2.23M|    }
 2135|  2.84M|  }
 2136|  2.23M|  return Result::Ok;
 2137|  2.38M|}
_ZN4wabt10WastParser25ParseTerminatingInstrListEPNS_14intrusive_listINS_4ExprEEE:
 2139|  2.11M|Result WastParser::ParseTerminatingInstrList(ExprList* exprs) {
 2140|  2.11M|  WABT_TRACE(ParseTerminatingInstrList);
 2141|  2.11M|  Result result = ParseInstrList(exprs);
 2142|       |  // An InstrList often has no further Lpar following it, because it would have
 2143|       |  // gobbled it up. So if there is a following Lpar it is an error. If we
 2144|       |  // handle it here we can produce a nicer error message.
 2145|  2.11M|  CHECK_RESULT(ErrorIfLpar({"an instr"}));
  ------------------
  |  |   55|  2.11M|  do {                              \
  |  |   56|  2.11M|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 72.7k, False: 2.04M]
  |  |  ------------------
  |  |   57|  72.7k|      return ::wabt::Result::Error; \
  |  |   58|  72.7k|    }                               \
  |  |   59|  2.11M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2146|  2.04M|  return result;
 2147|  2.11M|}
_ZN4wabt10WastParser10ParseInstrEPNS_14intrusive_listINS_4ExprEEE:
 2149|   604k|Result WastParser::ParseInstr(ExprList* exprs) {
 2150|   604k|  WABT_TRACE(ParseInstr);
 2151|   604k|  if (IsPlainInstr(Peek())) {
  ------------------
  |  Branch (2151:7): [True: 199k, False: 404k]
  ------------------
 2152|   199k|    std::unique_ptr<Expr> expr;
 2153|   199k|    CHECK_RESULT(ParsePlainInstr(&expr));
  ------------------
  |  |   55|   199k|  do {                              \
  |  |   56|   199k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 48.5k, False: 150k]
  |  |  ------------------
  |  |   57|  48.5k|      return ::wabt::Result::Error; \
  |  |   58|  48.5k|    }                               \
  |  |   59|   199k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2154|   150k|    exprs->push_back(std::move(expr));
 2155|   150k|    return Result::Ok;
 2156|   404k|  } else if (IsBlockInstr(Peek())) {
  ------------------
  |  Branch (2156:14): [True: 164k, False: 240k]
  ------------------
 2157|   164k|    std::unique_ptr<Expr> expr;
 2158|   164k|    CHECK_RESULT(ParseBlockInstr(&expr));
  ------------------
  |  |   55|   164k|  do {                              \
  |  |   56|   164k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 139k, False: 25.0k]
  |  |  ------------------
  |  |   57|   139k|      return ::wabt::Result::Error; \
  |  |   58|   139k|    }                               \
  |  |   59|   164k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2159|  25.0k|    exprs->push_back(std::move(expr));
 2160|  25.0k|    return Result::Ok;
 2161|   240k|  } else if (PeekMatchExpr()) {
  ------------------
  |  Branch (2161:14): [True: 240k, False: 0]
  ------------------
 2162|   240k|    return ParseExpr(exprs);
 2163|   240k|  } else {
 2164|      0|    assert(!"ParseInstr should only be called when IsInstr() is true");
 2165|      0|    return Result::Error;
 2166|      0|  }
 2167|   604k|}
_ZN4wabt10WastParser27ParseCodeMetadataAnnotationEPNS_14intrusive_listINS_4ExprEEE:
 2169|  6.86k|Result WastParser::ParseCodeMetadataAnnotation(ExprList* exprs) {
 2170|  6.86k|  WABT_TRACE(ParseCodeMetadataAnnotation);
 2171|  6.86k|  Token tk = Consume();
 2172|  6.86k|  std::string_view name = tk.text();
 2173|  6.86k|  name.remove_prefix(sizeof("metadata.code.") - 1);
 2174|  6.86k|  std::string data_text;
 2175|  6.86k|  CHECK_RESULT(ParseQuotedText(&data_text, false));
  ------------------
  |  |   55|  6.86k|  do {                              \
  |  |   56|  6.86k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.08k, False: 4.78k]
  |  |  ------------------
  |  |   57|  2.08k|      return ::wabt::Result::Error; \
  |  |   58|  2.08k|    }                               \
  |  |   59|  6.86k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2176|  4.78k|  std::vector<uint8_t> data(data_text.begin(), data_text.end());
 2177|  4.78k|  exprs->push_back(std::make_unique<CodeMetadataExpr>(name, std::move(data)));
 2178|  4.78k|  EXPECT(Rpar);
  ------------------
  |  |   31|  4.78k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  4.78k|  do {                              \
  |  |  |  |   56|  4.78k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 283, False: 4.49k]
  |  |  |  |  ------------------
  |  |  |  |   57|    283|      return ::wabt::Result::Error; \
  |  |  |  |   58|    283|    }                               \
  |  |  |  |   59|  4.78k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2179|  4.49k|  return Result::Ok;
 2180|  4.78k|}
_ZN4wabt10WastParser13ParseSimdLaneENS_8LocationEPm:
 2296|  16.1k|Result WastParser::ParseSimdLane(Location loc, uint64_t* lane_idx) {
 2297|  16.1k|  if (!PeekMatch(TokenType::Nat) && !PeekMatch(TokenType::Int)) {
  ------------------
  |  Branch (2297:7): [True: 8.35k, False: 7.80k]
  |  Branch (2297:37): [True: 6.45k, False: 1.90k]
  ------------------
 2298|  6.45k|    return ErrorExpected({"a natural number in range [0, 32)"});
 2299|  6.45k|  }
 2300|       |
 2301|  9.70k|  Literal literal = Consume().literal();
 2302|       |
 2303|  9.70k|  Result result =
 2304|  9.70k|      ParseInt64(literal.text, lane_idx, ParseIntType::UnsignedOnly);
 2305|       |
 2306|  9.70k|  if (Failed(result)) {
  ------------------
  |  Branch (2306:7): [True: 1.90k, False: 7.80k]
  ------------------
 2307|  1.90k|    Error(loc, "invalid literal \"" PRIstringview "\"",
 2308|  1.90k|          WABT_PRINTF_STRING_VIEW_ARG(literal.text));
  ------------------
  |  |   28|  1.90k|  static_cast<int>((x).length()), (x).data()
  ------------------
 2309|  1.90k|    return Result::Error;
 2310|  1.90k|  }
 2311|       |
 2312|       |  // The valid range is only [0, 32), but it's only malformed if it can't
 2313|       |  // fit in a byte.
 2314|  7.80k|  if (*lane_idx > 255) {
  ------------------
  |  Branch (2314:7): [True: 438, False: 7.36k]
  ------------------
 2315|    438|    Error(loc, "lane index \"" PRIstringview "\" out-of-range [0, 32)",
 2316|    438|          WABT_PRINTF_STRING_VIEW_ARG(literal.text));
  ------------------
  |  |   28|    438|  static_cast<int>((x).length()), (x).data()
  ------------------
 2317|    438|    return Result::Error;
 2318|    438|  }
 2319|       |
 2320|  7.36k|  return Result::Ok;
 2321|  7.80k|}
_ZN4wabt10WastParser15ParsePlainInstrEPNSt3__110unique_ptrINS_4ExprENS1_14default_deleteIS3_EEEE:
 2323|   752k|Result WastParser::ParsePlainInstr(std::unique_ptr<Expr>* out_expr) {
 2324|   752k|  WABT_TRACE(ParsePlainInstr);
 2325|   752k|  Location loc = GetLocation();
 2326|   752k|  switch (Peek()) {
 2327|    390|    case TokenType::Unreachable:
  ------------------
  |  Branch (2327:5): [True: 390, False: 752k]
  ------------------
 2328|    390|      Consume();
 2329|    390|      out_expr->reset(new UnreachableExpr(loc));
 2330|    390|      break;
 2331|       |
 2332|   201k|    case TokenType::Nop:
  ------------------
  |  Branch (2332:5): [True: 201k, False: 551k]
  ------------------
 2333|   201k|      Consume();
 2334|   201k|      out_expr->reset(new NopExpr(loc));
 2335|   201k|      break;
 2336|       |
 2337|  1.19k|    case TokenType::Drop:
  ------------------
  |  Branch (2337:5): [True: 1.19k, False: 751k]
  ------------------
 2338|  1.19k|      Consume();
 2339|  1.19k|      out_expr->reset(new DropExpr(loc));
 2340|  1.19k|      break;
 2341|       |
 2342|  1.65k|    case TokenType::Select: {
  ------------------
  |  Branch (2342:5): [True: 1.65k, False: 751k]
  ------------------
 2343|  1.65k|      Consume();
 2344|  1.65k|      TypeVector result;
 2345|  1.65k|      if (options_->features.reference_types_enabled() &&
  ------------------
  |  Branch (2345:11): [True: 1.65k, False: 0]
  ------------------
 2346|  1.65k|          PeekMatchLpar(TokenType::Result)) {
  ------------------
  |  Branch (2346:11): [True: 912, False: 745]
  ------------------
 2347|    912|        CHECK_RESULT(ParseResultList(&result, nullptr));
  ------------------
  |  |   55|    912|  do {                              \
  |  |   56|    912|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 410, False: 502]
  |  |  ------------------
  |  |   57|    410|      return ::wabt::Result::Error; \
  |  |   58|    410|    }                               \
  |  |   59|    912|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2348|    912|      }
 2349|  1.24k|      out_expr->reset(new SelectExpr(result, loc));
 2350|  1.24k|      break;
 2351|  1.65k|    }
 2352|       |
 2353|  22.2k|    case TokenType::Br:
  ------------------
  |  Branch (2353:5): [True: 22.2k, False: 730k]
  ------------------
 2354|  22.2k|      Consume();
 2355|  22.2k|      CHECK_RESULT(ParsePlainInstrVar<BrExpr>(loc, out_expr));
  ------------------
  |  |   55|  22.2k|  do {                              \
  |  |   56|  22.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.41k, False: 18.8k]
  |  |  ------------------
  |  |   57|  3.41k|      return ::wabt::Result::Error; \
  |  |   58|  3.41k|    }                               \
  |  |   59|  22.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2356|  18.8k|      break;
 2357|       |
 2358|  18.8k|    case TokenType::BrIf:
  ------------------
  |  Branch (2358:5): [True: 2.54k, False: 750k]
  ------------------
 2359|  2.54k|      Consume();
 2360|  2.54k|      CHECK_RESULT(ParsePlainInstrVar<BrIfExpr>(loc, out_expr));
  ------------------
  |  |   55|  2.54k|  do {                              \
  |  |   56|  2.54k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 376, False: 2.16k]
  |  |  ------------------
  |  |   57|    376|      return ::wabt::Result::Error; \
  |  |   58|    376|    }                               \
  |  |   59|  2.54k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2361|  2.16k|      break;
 2362|       |
 2363|  5.70k|    case TokenType::BrTable: {
  ------------------
  |  Branch (2363:5): [True: 5.70k, False: 747k]
  ------------------
 2364|  5.70k|      Consume();
 2365|  5.70k|      auto expr = std::make_unique<BrTableExpr>(loc);
 2366|  5.70k|      CHECK_RESULT(ParseVarList(&expr->targets));
  ------------------
  |  |   55|  5.70k|  do {                              \
  |  |   56|  5.70k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 4.50k, False: 1.20k]
  |  |  ------------------
  |  |   57|  4.50k|      return ::wabt::Result::Error; \
  |  |   58|  4.50k|    }                               \
  |  |   59|  5.70k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2367|  1.20k|      expr->default_target = expr->targets.back();
 2368|  1.20k|      expr->targets.pop_back();
 2369|  1.20k|      *out_expr = std::move(expr);
 2370|  1.20k|      break;
 2371|  5.70k|    }
 2372|       |
 2373|    765|    case TokenType::Return:
  ------------------
  |  Branch (2373:5): [True: 765, False: 751k]
  ------------------
 2374|    765|      Consume();
 2375|    765|      out_expr->reset(new ReturnExpr(loc));
 2376|    765|      break;
 2377|       |
 2378|  8.78k|    case TokenType::Call:
  ------------------
  |  Branch (2378:5): [True: 8.78k, False: 743k]
  ------------------
 2379|  8.78k|      Consume();
 2380|  8.78k|      CHECK_RESULT(ParsePlainInstrVar<CallExpr>(loc, out_expr));
  ------------------
  |  |   55|  8.78k|  do {                              \
  |  |   56|  8.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 632, False: 8.15k]
  |  |  ------------------
  |  |   57|    632|      return ::wabt::Result::Error; \
  |  |   58|    632|    }                               \
  |  |   59|  8.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2381|  8.15k|      break;
 2382|       |
 2383|  8.15k|    case TokenType::CallIndirect: {
  ------------------
  |  Branch (2383:5): [True: 3.71k, False: 749k]
  ------------------
 2384|  3.71k|      Consume();
 2385|  3.71k|      auto expr = std::make_unique<CallIndirectExpr>(loc);
 2386|  3.71k|      ParseVarOpt(&expr->table, Var(0, loc));
 2387|  3.71k|      CHECK_RESULT(ParseTypeUseOpt(&expr->decl));
  ------------------
  |  |   55|  3.71k|  do {                              \
  |  |   56|  3.71k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 294, False: 3.42k]
  |  |  ------------------
  |  |   57|    294|      return ::wabt::Result::Error; \
  |  |   58|    294|    }                               \
  |  |   59|  3.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2388|  3.42k|      CHECK_RESULT(ParseUnboundFuncSignature(&expr->decl.sig));
  ------------------
  |  |   55|  3.42k|  do {                              \
  |  |   56|  3.42k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 580, False: 2.84k]
  |  |  ------------------
  |  |   57|    580|      return ::wabt::Result::Error; \
  |  |   58|    580|    }                               \
  |  |   59|  3.42k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2389|  2.84k|      *out_expr = std::move(expr);
 2390|  2.84k|      break;
 2391|  3.42k|    }
 2392|       |
 2393|    431|    case TokenType::CallRef: {
  ------------------
  |  Branch (2393:5): [True: 431, False: 752k]
  ------------------
 2394|    431|      ErrorUnlessOpcodeEnabled(Consume());
 2395|    431|      out_expr->reset(new CallRefExpr(loc));
 2396|    431|      break;
 2397|  3.42k|    }
 2398|       |
 2399|  1.28k|    case TokenType::ReturnCall:
  ------------------
  |  Branch (2399:5): [True: 1.28k, False: 751k]
  ------------------
 2400|  1.28k|      ErrorUnlessOpcodeEnabled(Consume());
 2401|  1.28k|      CHECK_RESULT(ParsePlainInstrVar<ReturnCallExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.28k|  do {                              \
  |  |   56|  1.28k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 391, False: 889]
  |  |  ------------------
  |  |   57|    391|      return ::wabt::Result::Error; \
  |  |   58|    391|    }                               \
  |  |   59|  1.28k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2402|    889|      break;
 2403|       |
 2404|  3.74k|    case TokenType::ReturnCallIndirect: {
  ------------------
  |  Branch (2404:5): [True: 3.74k, False: 749k]
  ------------------
 2405|  3.74k|      ErrorUnlessOpcodeEnabled(Consume());
 2406|  3.74k|      auto expr = std::make_unique<ReturnCallIndirectExpr>(loc);
 2407|  3.74k|      ParseVarOpt(&expr->table, Var(0, loc));
 2408|  3.74k|      CHECK_RESULT(ParseTypeUseOpt(&expr->decl));
  ------------------
  |  |   55|  3.74k|  do {                              \
  |  |   56|  3.74k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 326, False: 3.41k]
  |  |  ------------------
  |  |   57|    326|      return ::wabt::Result::Error; \
  |  |   58|    326|    }                               \
  |  |   59|  3.74k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2409|  3.41k|      CHECK_RESULT(ParseUnboundFuncSignature(&expr->decl.sig));
  ------------------
  |  |   55|  3.41k|  do {                              \
  |  |   56|  3.41k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 471, False: 2.94k]
  |  |  ------------------
  |  |   57|    471|      return ::wabt::Result::Error; \
  |  |   58|    471|    }                               \
  |  |   59|  3.41k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2410|  2.94k|      *out_expr = std::move(expr);
 2411|  2.94k|      break;
 2412|  3.41k|    }
 2413|       |
 2414|  1.57k|    case TokenType::LocalGet:
  ------------------
  |  Branch (2414:5): [True: 1.57k, False: 751k]
  ------------------
 2415|  1.57k|      Consume();
 2416|  1.57k|      CHECK_RESULT(ParsePlainInstrVar<LocalGetExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.57k|  do {                              \
  |  |   56|  1.57k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 338, False: 1.23k]
  |  |  ------------------
  |  |   57|    338|      return ::wabt::Result::Error; \
  |  |   58|    338|    }                               \
  |  |   59|  1.57k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2417|  1.23k|      break;
 2418|       |
 2419|  1.46k|    case TokenType::LocalSet:
  ------------------
  |  Branch (2419:5): [True: 1.46k, False: 751k]
  ------------------
 2420|  1.46k|      Consume();
 2421|  1.46k|      CHECK_RESULT(ParsePlainInstrVar<LocalSetExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.46k|  do {                              \
  |  |   56|  1.46k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 342, False: 1.12k]
  |  |  ------------------
  |  |   57|    342|      return ::wabt::Result::Error; \
  |  |   58|    342|    }                               \
  |  |   59|  1.46k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2422|  1.12k|      break;
 2423|       |
 2424|  2.29k|    case TokenType::LocalTee:
  ------------------
  |  Branch (2424:5): [True: 2.29k, False: 750k]
  ------------------
 2425|  2.29k|      Consume();
 2426|  2.29k|      CHECK_RESULT(ParsePlainInstrVar<LocalTeeExpr>(loc, out_expr));
  ------------------
  |  |   55|  2.29k|  do {                              \
  |  |   56|  2.29k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 382, False: 1.91k]
  |  |  ------------------
  |  |   57|    382|      return ::wabt::Result::Error; \
  |  |   58|    382|    }                               \
  |  |   59|  2.29k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2427|  1.91k|      break;
 2428|       |
 2429|  1.91k|    case TokenType::GlobalGet:
  ------------------
  |  Branch (2429:5): [True: 1.32k, False: 751k]
  ------------------
 2430|  1.32k|      Consume();
 2431|  1.32k|      CHECK_RESULT(ParsePlainInstrVar<GlobalGetExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.32k|  do {                              \
  |  |   56|  1.32k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 388, False: 932]
  |  |  ------------------
  |  |   57|    388|      return ::wabt::Result::Error; \
  |  |   58|    388|    }                               \
  |  |   59|  1.32k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2432|    932|      break;
 2433|       |
 2434|  1.21k|    case TokenType::GlobalSet:
  ------------------
  |  Branch (2434:5): [True: 1.21k, False: 751k]
  ------------------
 2435|  1.21k|      Consume();
 2436|  1.21k|      CHECK_RESULT(ParsePlainInstrVar<GlobalSetExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.21k|  do {                              \
  |  |   56|  1.21k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 352, False: 862]
  |  |  ------------------
  |  |   57|    352|      return ::wabt::Result::Error; \
  |  |   58|    352|    }                               \
  |  |   59|  1.21k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2437|    862|      break;
 2438|       |
 2439|  13.1k|    case TokenType::Load:
  ------------------
  |  Branch (2439:5): [True: 13.1k, False: 739k]
  ------------------
 2440|  13.1k|      CHECK_RESULT(ParseLoadStoreInstr<LoadExpr>(loc, Consume(), out_expr));
  ------------------
  |  |   55|  13.1k|  do {                              \
  |  |   56|  13.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 564, False: 12.6k]
  |  |  ------------------
  |  |   57|    564|      return ::wabt::Result::Error; \
  |  |   58|    564|    }                               \
  |  |   59|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2441|  12.6k|      break;
 2442|       |
 2443|  12.6k|    case TokenType::Store:
  ------------------
  |  Branch (2443:5): [True: 1.72k, False: 751k]
  ------------------
 2444|  1.72k|      CHECK_RESULT(ParseLoadStoreInstr<StoreExpr>(loc, Consume(), out_expr));
  ------------------
  |  |   55|  1.72k|  do {                              \
  |  |   56|  1.72k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 227, False: 1.49k]
  |  |  ------------------
  |  |   57|    227|      return ::wabt::Result::Error; \
  |  |   58|    227|    }                               \
  |  |   59|  1.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2445|  1.49k|      break;
 2446|       |
 2447|   329k|    case TokenType::Const: {
  ------------------
  |  Branch (2447:5): [True: 329k, False: 423k]
  ------------------
 2448|   329k|      Const const_;
 2449|   329k|      CHECK_RESULT(ParseConst(&const_, ConstType::Normal));
  ------------------
  |  |   55|   329k|  do {                              \
  |  |   56|   329k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 84.4k, False: 244k]
  |  |  ------------------
  |  |   57|  84.4k|      return ::wabt::Result::Error; \
  |  |   58|  84.4k|    }                               \
  |  |   59|   329k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2450|   244k|      out_expr->reset(new ConstExpr(const_, loc));
 2451|   244k|      break;
 2452|   329k|    }
 2453|       |
 2454|  21.2k|    case TokenType::Unary: {
  ------------------
  |  Branch (2454:5): [True: 21.2k, False: 731k]
  ------------------
 2455|  21.2k|      Token token = Consume();
 2456|  21.2k|      ErrorUnlessOpcodeEnabled(token);
 2457|  21.2k|      out_expr->reset(new UnaryExpr(token.opcode(), loc));
 2458|  21.2k|      break;
 2459|   329k|    }
 2460|       |
 2461|  22.4k|    case TokenType::Binary: {
  ------------------
  |  Branch (2461:5): [True: 22.4k, False: 730k]
  ------------------
 2462|  22.4k|      Token token = Consume();
 2463|  22.4k|      ErrorUnlessOpcodeEnabled(token);
 2464|  22.4k|      out_expr->reset(new BinaryExpr(token.opcode(), loc));
 2465|  22.4k|      break;
 2466|   329k|    }
 2467|       |
 2468|    470|    case TokenType::Compare:
  ------------------
  |  Branch (2468:5): [True: 470, False: 752k]
  ------------------
 2469|    470|      out_expr->reset(new CompareExpr(Consume().opcode(), loc));
 2470|    470|      break;
 2471|       |
 2472|  2.18k|    case TokenType::Convert: {
  ------------------
  |  Branch (2472:5): [True: 2.18k, False: 750k]
  ------------------
 2473|  2.18k|      Token token = Consume();
 2474|  2.18k|      ErrorUnlessOpcodeEnabled(token);
 2475|  2.18k|      out_expr->reset(new ConvertExpr(token.opcode(), loc));
 2476|  2.18k|      break;
 2477|   329k|    }
 2478|       |
 2479|    870|    case TokenType::MemoryCopy:
  ------------------
  |  Branch (2479:5): [True: 870, False: 751k]
  ------------------
 2480|    870|      ErrorUnlessOpcodeEnabled(Consume());
 2481|    870|      CHECK_RESULT(ParseMemoryBinaryExpr<MemoryCopyExpr>(loc, out_expr));
  ------------------
  |  |   55|    870|  do {                              \
  |  |   56|    870|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 197, False: 673]
  |  |  ------------------
  |  |   57|    197|      return ::wabt::Result::Error; \
  |  |   58|    197|    }                               \
  |  |   59|    870|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2482|    673|      break;
 2483|       |
 2484|    721|    case TokenType::MemoryFill:
  ------------------
  |  Branch (2484:5): [True: 721, False: 752k]
  ------------------
 2485|    721|      ErrorUnlessOpcodeEnabled(Consume());
 2486|    721|      CHECK_RESULT(ParseMemoryExpr<MemoryFillExpr>(loc, out_expr));
  ------------------
  |  |   55|    721|  do {                              \
  |  |   56|    721|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 311, False: 410]
  |  |  ------------------
  |  |   57|    311|      return ::wabt::Result::Error; \
  |  |   58|    311|    }                               \
  |  |   59|    721|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2487|    410|      break;
 2488|       |
 2489|  1.45k|    case TokenType::DataDrop:
  ------------------
  |  Branch (2489:5): [True: 1.45k, False: 751k]
  ------------------
 2490|  1.45k|      ErrorUnlessOpcodeEnabled(Consume());
 2491|  1.45k|      CHECK_RESULT(ParsePlainInstrVar<DataDropExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.45k|  do {                              \
  |  |   56|  1.45k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 417, False: 1.04k]
  |  |  ------------------
  |  |   57|    417|      return ::wabt::Result::Error; \
  |  |   58|    417|    }                               \
  |  |   59|  1.45k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2492|  1.04k|      break;
 2493|       |
 2494|  2.06k|    case TokenType::MemoryInit:
  ------------------
  |  Branch (2494:5): [True: 2.06k, False: 750k]
  ------------------
 2495|  2.06k|      ErrorUnlessOpcodeEnabled(Consume());
 2496|  2.06k|      CHECK_RESULT(ParseMemoryInstrVar<MemoryInitExpr>(loc, out_expr));
  ------------------
  |  |   55|  2.06k|  do {                              \
  |  |   56|  2.06k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.15k, False: 909]
  |  |  ------------------
  |  |   57|  1.15k|      return ::wabt::Result::Error; \
  |  |   58|  1.15k|    }                               \
  |  |   59|  2.06k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2497|    909|      break;
 2498|       |
 2499|  6.00k|    case TokenType::MemorySize:
  ------------------
  |  Branch (2499:5): [True: 6.00k, False: 746k]
  ------------------
 2500|  6.00k|      Consume();
 2501|  6.00k|      CHECK_RESULT(ParseMemoryExpr<MemorySizeExpr>(loc, out_expr));
  ------------------
  |  |   55|  6.00k|  do {                              \
  |  |   56|  6.00k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 227, False: 5.77k]
  |  |  ------------------
  |  |   57|    227|      return ::wabt::Result::Error; \
  |  |   58|    227|    }                               \
  |  |   59|  6.00k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2502|  5.77k|      break;
 2503|       |
 2504|  5.77k|    case TokenType::MemoryGrow:
  ------------------
  |  Branch (2504:5): [True: 956, False: 751k]
  ------------------
 2505|    956|      Consume();
 2506|    956|      CHECK_RESULT(ParseMemoryExpr<MemoryGrowExpr>(loc, out_expr));
  ------------------
  |  |   55|    956|  do {                              \
  |  |   56|    956|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 304, False: 652]
  |  |  ------------------
  |  |   57|    304|      return ::wabt::Result::Error; \
  |  |   58|    304|    }                               \
  |  |   59|    956|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2507|    652|      break;
 2508|       |
 2509|  2.55k|    case TokenType::TableCopy: {
  ------------------
  |  Branch (2509:5): [True: 2.55k, False: 750k]
  ------------------
 2510|  2.55k|      ErrorUnlessOpcodeEnabled(Consume());
 2511|  2.55k|      Var dst(0, loc);
 2512|  2.55k|      Var src(0, loc);
 2513|  2.55k|      if (options_->features.reference_types_enabled()) {
  ------------------
  |  Branch (2513:11): [True: 2.55k, False: 0]
  ------------------
 2514|  2.55k|        ParseVarOpt(&dst, dst);
 2515|  2.55k|        ParseVarOpt(&src, src);
 2516|  2.55k|      }
 2517|  2.55k|      out_expr->reset(new TableCopyExpr(dst, src, loc));
 2518|  2.55k|      break;
 2519|    956|    }
 2520|       |
 2521|  1.79k|    case TokenType::ElemDrop:
  ------------------
  |  Branch (2521:5): [True: 1.79k, False: 750k]
  ------------------
 2522|  1.79k|      ErrorUnlessOpcodeEnabled(Consume());
 2523|  1.79k|      CHECK_RESULT(ParsePlainInstrVar<ElemDropExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.79k|  do {                              \
  |  |   56|  1.79k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 388, False: 1.40k]
  |  |  ------------------
  |  |   57|    388|      return ::wabt::Result::Error; \
  |  |   58|    388|    }                               \
  |  |   59|  1.79k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2524|  1.40k|      break;
 2525|       |
 2526|  5.18k|    case TokenType::TableInit: {
  ------------------
  |  Branch (2526:5): [True: 5.18k, False: 747k]
  ------------------
 2527|  5.18k|      ErrorUnlessOpcodeEnabled(Consume());
 2528|  5.18k|      Var segment_index(0, loc);
 2529|  5.18k|      CHECK_RESULT(ParseVar(&segment_index));
  ------------------
  |  |   55|  5.18k|  do {                              \
  |  |   56|  5.18k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 473, False: 4.71k]
  |  |  ------------------
  |  |   57|    473|      return ::wabt::Result::Error; \
  |  |   58|    473|    }                               \
  |  |   59|  5.18k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2530|  4.71k|      Var table_index(0, loc);
 2531|  4.71k|      if (ParseVarOpt(&table_index, table_index)) {
  ------------------
  |  Branch (2531:11): [True: 2.78k, False: 1.93k]
  ------------------
 2532|       |        // Here are the two forms:
 2533|       |        //
 2534|       |        //   table.init $elemidx ...
 2535|       |        //   table.init $tableidx $elemidx ...
 2536|       |        //
 2537|       |        // So if both indexes are provided, we need to swap them.
 2538|  2.78k|        std::swap(segment_index, table_index);
 2539|  2.78k|      }
 2540|  4.71k|      out_expr->reset(new TableInitExpr(segment_index, table_index, loc));
 2541|  4.71k|      break;
 2542|  5.18k|    }
 2543|       |
 2544|  1.07k|    case TokenType::TableGet: {
  ------------------
  |  Branch (2544:5): [True: 1.07k, False: 751k]
  ------------------
 2545|  1.07k|      ErrorUnlessOpcodeEnabled(Consume());
 2546|  1.07k|      Var table_index(0, loc);
 2547|  1.07k|      ParseVarOpt(&table_index, table_index);
 2548|  1.07k|      out_expr->reset(new TableGetExpr(table_index, loc));
 2549|  1.07k|      break;
 2550|  5.18k|    }
 2551|       |
 2552|  1.25k|    case TokenType::TableSet: {
  ------------------
  |  Branch (2552:5): [True: 1.25k, False: 751k]
  ------------------
 2553|  1.25k|      ErrorUnlessOpcodeEnabled(Consume());
 2554|  1.25k|      Var table_index(0, loc);
 2555|  1.25k|      ParseVarOpt(&table_index, table_index);
 2556|  1.25k|      out_expr->reset(new TableSetExpr(table_index, loc));
 2557|  1.25k|      break;
 2558|  5.18k|    }
 2559|       |
 2560|  1.91k|    case TokenType::TableGrow: {
  ------------------
  |  Branch (2560:5): [True: 1.91k, False: 750k]
  ------------------
 2561|  1.91k|      ErrorUnlessOpcodeEnabled(Consume());
 2562|  1.91k|      Var table_index(0, loc);
 2563|  1.91k|      ParseVarOpt(&table_index, table_index);
 2564|  1.91k|      out_expr->reset(new TableGrowExpr(table_index, loc));
 2565|  1.91k|      break;
 2566|  5.18k|    }
 2567|       |
 2568|  1.96k|    case TokenType::TableSize: {
  ------------------
  |  Branch (2568:5): [True: 1.96k, False: 750k]
  ------------------
 2569|  1.96k|      ErrorUnlessOpcodeEnabled(Consume());
 2570|  1.96k|      Var table_index(0, loc);
 2571|  1.96k|      ParseVarOpt(&table_index, table_index);
 2572|  1.96k|      out_expr->reset(new TableSizeExpr(table_index, loc));
 2573|  1.96k|      break;
 2574|  5.18k|    }
 2575|       |
 2576|  1.18k|    case TokenType::TableFill: {
  ------------------
  |  Branch (2576:5): [True: 1.18k, False: 751k]
  ------------------
 2577|  1.18k|      ErrorUnlessOpcodeEnabled(Consume());
 2578|  1.18k|      Var table_index(0, loc);
 2579|  1.18k|      ParseVarOpt(&table_index, table_index);
 2580|  1.18k|      out_expr->reset(new TableFillExpr(table_index, loc));
 2581|  1.18k|      break;
 2582|  5.18k|    }
 2583|       |
 2584|  1.32k|    case TokenType::RefFunc:
  ------------------
  |  Branch (2584:5): [True: 1.32k, False: 751k]
  ------------------
 2585|  1.32k|      ErrorUnlessOpcodeEnabled(Consume());
 2586|  1.32k|      CHECK_RESULT(ParsePlainInstrVar<RefFuncExpr>(loc, out_expr));
  ------------------
  |  |   55|  1.32k|  do {                              \
  |  |   56|  1.32k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 425, False: 895]
  |  |  ------------------
  |  |   57|    425|      return ::wabt::Result::Error; \
  |  |   58|    425|    }                               \
  |  |   59|  1.32k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2587|    895|      break;
 2588|       |
 2589|  1.21k|    case TokenType::RefNull: {
  ------------------
  |  Branch (2589:5): [True: 1.21k, False: 751k]
  ------------------
 2590|  1.21k|      ErrorUnlessOpcodeEnabled(Consume());
 2591|  1.21k|      Type type;
 2592|  1.21k|      CHECK_RESULT(ParseRefKind(&type));
  ------------------
  |  |   55|  1.21k|  do {                              \
  |  |   56|  1.21k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 710, False: 503]
  |  |  ------------------
  |  |   57|    710|      return ::wabt::Result::Error; \
  |  |   58|    710|    }                               \
  |  |   59|  1.21k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2593|    503|      out_expr->reset(new RefNullExpr(type, loc));
 2594|    503|      break;
 2595|  1.21k|    }
 2596|       |
 2597|    509|    case TokenType::RefIsNull:
  ------------------
  |  Branch (2597:5): [True: 509, False: 752k]
  ------------------
 2598|    509|      ErrorUnlessOpcodeEnabled(Consume());
 2599|    509|      out_expr->reset(new RefIsNullExpr(loc));
 2600|    509|      break;
 2601|       |
 2602|  4.60k|    case TokenType::Throw:
  ------------------
  |  Branch (2602:5): [True: 4.60k, False: 748k]
  ------------------
 2603|  4.60k|      ErrorUnlessOpcodeEnabled(Consume());
 2604|  4.60k|      CHECK_RESULT(ParsePlainInstrVar<ThrowExpr>(loc, out_expr));
  ------------------
  |  |   55|  4.60k|  do {                              \
  |  |   56|  4.60k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.40k, False: 3.20k]
  |  |  ------------------
  |  |   57|  1.40k|      return ::wabt::Result::Error; \
  |  |   58|  1.40k|    }                               \
  |  |   59|  4.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2605|  3.20k|      break;
 2606|       |
 2607|  3.20k|    case TokenType::ThrowRef:
  ------------------
  |  Branch (2607:5): [True: 581, False: 752k]
  ------------------
 2608|    581|      ErrorUnlessOpcodeEnabled(Consume());
 2609|    581|      out_expr->reset(new ThrowRefExpr(loc));
 2610|    581|      break;
 2611|       |
 2612|    743|    case TokenType::Rethrow:
  ------------------
  |  Branch (2612:5): [True: 743, False: 752k]
  ------------------
 2613|    743|      ErrorUnlessOpcodeEnabled(Consume());
 2614|    743|      CHECK_RESULT(ParsePlainInstrVar<RethrowExpr>(loc, out_expr));
  ------------------
  |  |   55|    743|  do {                              \
  |  |   56|    743|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 465, False: 278]
  |  |  ------------------
  |  |   57|    465|      return ::wabt::Result::Error; \
  |  |   58|    465|    }                               \
  |  |   59|    743|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2615|    278|      break;
 2616|       |
 2617|    611|    case TokenType::AtomicNotify: {
  ------------------
  |  Branch (2617:5): [True: 611, False: 752k]
  ------------------
 2618|    611|      Token token = Consume();
 2619|    611|      ErrorUnlessOpcodeEnabled(token);
 2620|    611|      CHECK_RESULT(ParseLoadStoreInstr<AtomicNotifyExpr>(loc, token, out_expr));
  ------------------
  |  |   55|    611|  do {                              \
  |  |   56|    611|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 195, False: 416]
  |  |  ------------------
  |  |   57|    195|      return ::wabt::Result::Error; \
  |  |   58|    195|    }                               \
  |  |   59|    611|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2621|    416|      break;
 2622|    611|    }
 2623|       |
 2624|    500|    case TokenType::AtomicFence: {
  ------------------
  |  Branch (2624:5): [True: 500, False: 752k]
  ------------------
 2625|    500|      Token token = Consume();
 2626|    500|      ErrorUnlessOpcodeEnabled(token);
 2627|    500|      uint32_t consistency_model = 0x0;
 2628|    500|      out_expr->reset(new AtomicFenceExpr(consistency_model, loc));
 2629|    500|      break;
 2630|    611|    }
 2631|       |
 2632|  1.04k|    case TokenType::AtomicWait: {
  ------------------
  |  Branch (2632:5): [True: 1.04k, False: 751k]
  ------------------
 2633|  1.04k|      Token token = Consume();
 2634|  1.04k|      ErrorUnlessOpcodeEnabled(token);
 2635|  1.04k|      CHECK_RESULT(ParseLoadStoreInstr<AtomicWaitExpr>(loc, token, out_expr));
  ------------------
  |  |   55|  1.04k|  do {                              \
  |  |   56|  1.04k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 505, False: 539]
  |  |  ------------------
  |  |   57|    505|      return ::wabt::Result::Error; \
  |  |   58|    505|    }                               \
  |  |   59|  1.04k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2636|    539|      break;
 2637|  1.04k|    }
 2638|       |
 2639|  2.07k|    case TokenType::AtomicLoad: {
  ------------------
  |  Branch (2639:5): [True: 2.07k, False: 750k]
  ------------------
 2640|  2.07k|      Token token = Consume();
 2641|  2.07k|      ErrorUnlessOpcodeEnabled(token);
 2642|  2.07k|      CHECK_RESULT(ParseLoadStoreInstr<AtomicLoadExpr>(loc, token, out_expr));
  ------------------
  |  |   55|  2.07k|  do {                              \
  |  |   56|  2.07k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 201, False: 1.87k]
  |  |  ------------------
  |  |   57|    201|      return ::wabt::Result::Error; \
  |  |   58|    201|    }                               \
  |  |   59|  2.07k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2643|  1.87k|      break;
 2644|  2.07k|    }
 2645|       |
 2646|  13.3k|    case TokenType::AtomicStore: {
  ------------------
  |  Branch (2646:5): [True: 13.3k, False: 739k]
  ------------------
 2647|  13.3k|      Token token = Consume();
 2648|  13.3k|      ErrorUnlessOpcodeEnabled(token);
 2649|  13.3k|      CHECK_RESULT(ParseLoadStoreInstr<AtomicStoreExpr>(loc, token, out_expr));
  ------------------
  |  |   55|  13.3k|  do {                              \
  |  |   56|  13.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 11.5k, False: 1.72k]
  |  |  ------------------
  |  |   57|  11.5k|      return ::wabt::Result::Error; \
  |  |   58|  11.5k|    }                               \
  |  |   59|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2650|  1.72k|      break;
 2651|  13.3k|    }
 2652|       |
 2653|  20.1k|    case TokenType::AtomicRmw: {
  ------------------
  |  Branch (2653:5): [True: 20.1k, False: 732k]
  ------------------
 2654|  20.1k|      Token token = Consume();
 2655|  20.1k|      ErrorUnlessOpcodeEnabled(token);
 2656|  20.1k|      CHECK_RESULT(ParseLoadStoreInstr<AtomicRmwExpr>(loc, token, out_expr));
  ------------------
  |  |   55|  20.1k|  do {                              \
  |  |   56|  20.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 790, False: 19.3k]
  |  |  ------------------
  |  |   57|    790|      return ::wabt::Result::Error; \
  |  |   58|    790|    }                               \
  |  |   59|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2657|  19.3k|      break;
 2658|  20.1k|    }
 2659|       |
 2660|  19.3k|    case TokenType::AtomicRmwCmpxchg: {
  ------------------
  |  Branch (2660:5): [True: 10.4k, False: 742k]
  ------------------
 2661|  10.4k|      Token token = Consume();
 2662|  10.4k|      ErrorUnlessOpcodeEnabled(token);
 2663|  10.4k|      CHECK_RESULT(
  ------------------
  |  |   55|  10.4k|  do {                              \
  |  |   56|  10.4k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 359, False: 10.0k]
  |  |  ------------------
  |  |   57|    359|      return ::wabt::Result::Error; \
  |  |   58|    359|    }                               \
  |  |   59|  10.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2664|  10.4k|          ParseLoadStoreInstr<AtomicRmwCmpxchgExpr>(loc, token, out_expr));
 2665|  10.0k|      break;
 2666|  10.4k|    }
 2667|       |
 2668|  10.0k|    case TokenType::Ternary: {
  ------------------
  |  Branch (2668:5): [True: 4.14k, False: 748k]
  ------------------
 2669|  4.14k|      Token token = Consume();
 2670|  4.14k|      ErrorUnlessOpcodeEnabled(token);
 2671|  4.14k|      out_expr->reset(new TernaryExpr(token.opcode(), loc));
 2672|  4.14k|      break;
 2673|  10.4k|    }
 2674|       |
 2675|  3.88k|    case TokenType::SimdLaneOp: {
  ------------------
  |  Branch (2675:5): [True: 3.88k, False: 748k]
  ------------------
 2676|  3.88k|      Token token = Consume();
 2677|  3.88k|      ErrorUnlessOpcodeEnabled(token);
 2678|       |
 2679|  3.88k|      uint64_t lane_idx = 0;
 2680|  3.88k|      Result result = ParseSimdLane(loc, &lane_idx);
 2681|       |
 2682|  3.88k|      if (Failed(result)) {
  ------------------
  |  Branch (2682:11): [True: 3.43k, False: 446]
  ------------------
 2683|  3.43k|        return Result::Error;
 2684|  3.43k|      }
 2685|       |
 2686|    446|      out_expr->reset(new SimdLaneOpExpr(token.opcode(), lane_idx, loc));
 2687|    446|      break;
 2688|  3.88k|    }
 2689|       |
 2690|  1.28k|    case TokenType::SimdLoadLane: {
  ------------------
  |  Branch (2690:5): [True: 1.28k, False: 751k]
  ------------------
 2691|  1.28k|      CHECK_RESULT(
  ------------------
  |  |   55|  1.28k|  do {                              \
  |  |   56|  1.28k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 936, False: 345]
  |  |  ------------------
  |  |   57|    936|      return ::wabt::Result::Error; \
  |  |   58|    936|    }                               \
  |  |   59|  1.28k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2692|  1.28k|          ParseSIMDLoadStoreInstr<SimdLoadLaneExpr>(loc, Consume(), out_expr));
 2693|    345|      break;
 2694|  1.28k|    }
 2695|       |
 2696|  2.15k|    case TokenType::SimdStoreLane: {
  ------------------
  |  Branch (2696:5): [True: 2.15k, False: 750k]
  ------------------
 2697|  2.15k|      CHECK_RESULT(
  ------------------
  |  |   55|  2.15k|  do {                              \
  |  |   56|  2.15k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.60k, False: 547]
  |  |  ------------------
  |  |   57|  1.60k|      return ::wabt::Result::Error; \
  |  |   58|  1.60k|    }                               \
  |  |   59|  2.15k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2698|  2.15k|          ParseSIMDLoadStoreInstr<SimdStoreLaneExpr>(loc, Consume(), out_expr));
 2699|    547|      break;
 2700|  2.15k|    }
 2701|       |
 2702|  3.12k|    case TokenType::SimdShuffleOp: {
  ------------------
  |  Branch (2702:5): [True: 3.12k, False: 749k]
  ------------------
 2703|  3.12k|      Token token = Consume();
 2704|  3.12k|      ErrorUnlessOpcodeEnabled(token);
 2705|  3.12k|      v128 values;
 2706|  9.15k|      for (int lane = 0; lane < 16; ++lane) {
  ------------------
  |  Branch (2706:26): [True: 8.84k, False: 310]
  ------------------
 2707|  8.84k|        Location loc = GetLocation();
 2708|  8.84k|        uint64_t lane_idx;
 2709|  8.84k|        Result result = ParseSimdLane(loc, &lane_idx);
 2710|  8.84k|        if (Failed(result)) {
  ------------------
  |  Branch (2710:13): [True: 2.81k, False: 6.02k]
  ------------------
 2711|  2.81k|          return Result::Error;
 2712|  2.81k|        }
 2713|       |
 2714|  6.02k|        values.set_u8(lane, static_cast<uint8_t>(lane_idx));
 2715|  6.02k|      }
 2716|       |
 2717|    310|      out_expr->reset(new SimdShuffleOpExpr(token.opcode(), values, loc));
 2718|    310|      break;
 2719|  3.12k|    }
 2720|       |
 2721|      0|    default:
  ------------------
  |  Branch (2721:5): [True: 0, False: 752k]
  ------------------
 2722|      0|      assert(
 2723|      0|          !"ParsePlainInstr should only be called when IsPlainInstr() is true");
 2724|      0|      return Result::Error;
 2725|   752k|  }
 2726|       |
 2727|   625k|  return Result::Ok;
 2728|   752k|}
_ZN4wabt10WastParser18ParseSimdV128ConstEPNS_5ConstENS_9TokenTypeENS0_9ConstTypeE:
 2732|  62.6k|                                      ConstType const_type) {
 2733|  62.6k|  WABT_TRACE(ParseSimdV128Const);
 2734|       |
 2735|  62.6k|  uint8_t lane_count = 0;
 2736|  62.6k|  bool integer = true;
 2737|  62.6k|  switch (token_type) {
 2738|  1.22k|    case TokenType::I8X16: { lane_count = 16; break; }
  ------------------
  |  Branch (2738:5): [True: 1.22k, False: 61.3k]
  ------------------
 2739|  2.90k|    case TokenType::I16X8: { lane_count = 8; break; }
  ------------------
  |  Branch (2739:5): [True: 2.90k, False: 59.7k]
  ------------------
 2740|    377|    case TokenType::I32X4: { lane_count = 4; break; }
  ------------------
  |  Branch (2740:5): [True: 377, False: 62.2k]
  ------------------
 2741|    524|    case TokenType::I64X2: { lane_count = 2; break; }
  ------------------
  |  Branch (2741:5): [True: 524, False: 62.0k]
  ------------------
 2742|  3.89k|    case TokenType::F32X4: { lane_count = 4; integer = false; break; }
  ------------------
  |  Branch (2742:5): [True: 3.89k, False: 58.7k]
  ------------------
 2743|  51.3k|    case TokenType::F64X2: { lane_count = 2; integer = false; break; }
  ------------------
  |  Branch (2743:5): [True: 51.3k, False: 11.2k]
  ------------------
 2744|  2.35k|    default: {
  ------------------
  |  Branch (2744:5): [True: 2.35k, False: 60.2k]
  ------------------
 2745|  2.35k|      Error(const_->loc,
 2746|  2.35k|            "Unexpected type at start of simd constant. "
 2747|  2.35k|            "Expected one of: i8x16, i16x8, i32x4, i64x2, f32x4, f64x2. "
 2748|  2.35k|            "Found \"%s\".",
 2749|  2.35k|            GetTokenTypeName(token_type));
 2750|  2.35k|      return Result::Error;
 2751|      0|    }
 2752|  62.6k|  }
 2753|  60.2k|  Consume();
 2754|       |
 2755|  60.2k|  const_->loc = GetLocation();
 2756|       |
 2757|   166k|  for (int lane = 0; lane < lane_count; ++lane) {
  ------------------
  |  Branch (2757:22): [True: 119k, False: 47.1k]
  ------------------
 2758|   119k|    Location loc = GetLocation();
 2759|       |
 2760|       |    // Check that the lane literal type matches the element type of the v128:
 2761|   119k|    Token token = GetToken();
 2762|   119k|    switch (token.token_type()) {
 2763|  6.75k|      case TokenType::Nat:
  ------------------
  |  Branch (2763:7): [True: 6.75k, False: 112k]
  ------------------
 2764|  10.3k|      case TokenType::Int:
  ------------------
  |  Branch (2764:7): [True: 3.58k, False: 115k]
  ------------------
 2765|       |        // OK.
 2766|  10.3k|        break;
 2767|       |
 2768|  98.8k|      case TokenType::Float:
  ------------------
  |  Branch (2768:7): [True: 98.8k, False: 20.3k]
  ------------------
 2769|  99.0k|      case TokenType::NanArithmetic:
  ------------------
  |  Branch (2769:7): [True: 194, False: 118k]
  ------------------
 2770|  99.3k|      case TokenType::NanCanonical:
  ------------------
  |  Branch (2770:7): [True: 241, False: 118k]
  ------------------
 2771|  99.3k|        if (integer) {
  ------------------
  |  Branch (2771:13): [True: 362, False: 98.9k]
  ------------------
 2772|    362|          goto error;
 2773|    362|        }
 2774|  98.9k|        break;
 2775|       |
 2776|  98.9k|      error:
 2777|  9.89k|      default:
  ------------------
  |  Branch (2777:7): [True: 9.53k, False: 109k]
  ------------------
 2778|  9.89k|        if (integer) {
  ------------------
  |  Branch (2778:13): [True: 1.55k, False: 8.33k]
  ------------------
 2779|  1.55k|          return ErrorExpected({"a Nat or Integer literal"}, "123");
 2780|  8.33k|        } else {
 2781|  8.33k|          return ErrorExpected({"a Float literal"}, "42.0");
 2782|  8.33k|        }
 2783|   119k|    }
 2784|       |
 2785|   109k|    Result result;
 2786|       |
 2787|       |    // For each type, parse the next literal, bound check it, and write it to
 2788|       |    // the array of bytes:
 2789|   109k|    if (integer) {
  ------------------
  |  Branch (2789:9): [True: 8.90k, False: 100k]
  ------------------
 2790|  8.90k|      std::string_view sv = Consume().literal().text;
 2791|       |
 2792|  8.90k|      switch (lane_count) {
  ------------------
  |  Branch (2792:15): [True: 0, False: 8.90k]
  ------------------
 2793|  2.52k|        case 16: {
  ------------------
  |  Branch (2793:9): [True: 2.52k, False: 6.38k]
  ------------------
 2794|  2.52k|          uint8_t value = 0;
 2795|  2.52k|          result = ParseInt8(sv, &value, ParseIntType::SignedAndUnsigned);
 2796|  2.52k|          const_->set_v128_u8(lane, value);
 2797|  2.52k|          break;
 2798|      0|        }
 2799|  4.40k|        case 8: {
  ------------------
  |  Branch (2799:9): [True: 4.40k, False: 4.49k]
  ------------------
 2800|  4.40k|          uint16_t value = 0;
 2801|  4.40k|          result = ParseInt16(sv, &value, ParseIntType::SignedAndUnsigned);
 2802|  4.40k|          const_->set_v128_u16(lane, value);
 2803|  4.40k|          break;
 2804|      0|        }
 2805|    978|        case 4: {
  ------------------
  |  Branch (2805:9): [True: 978, False: 7.92k]
  ------------------
 2806|    978|          uint32_t value = 0;
 2807|    978|          result = ParseInt32(sv, &value, ParseIntType::SignedAndUnsigned);
 2808|    978|          const_->set_v128_u32(lane, value);
 2809|    978|          break;
 2810|      0|        }
 2811|    999|        case 2: {
  ------------------
  |  Branch (2811:9): [True: 999, False: 7.90k]
  ------------------
 2812|    999|          uint64_t value = 0;
 2813|    999|          result = ParseInt64(sv, &value, ParseIntType::SignedAndUnsigned);
 2814|    999|          const_->set_v128_u64(lane, value);
 2815|    999|          break;
 2816|      0|        }
 2817|  8.90k|      }
 2818|   100k|    } else {
 2819|   100k|      Const lane_const_;
 2820|   100k|      switch (lane_count) {
  ------------------
  |  Branch (2820:15): [True: 0, False: 100k]
  ------------------
 2821|  7.20k|        case 4:
  ------------------
  |  Branch (2821:9): [True: 7.20k, False: 93.1k]
  ------------------
 2822|  7.20k|          result = ParseF32(&lane_const_, const_type);
 2823|  7.20k|          const_->set_v128_f32(lane, lane_const_.f32_bits());
 2824|  7.20k|          break;
 2825|       |
 2826|  93.1k|        case 2:
  ------------------
  |  Branch (2826:9): [True: 93.1k, False: 7.20k]
  ------------------
 2827|  93.1k|          result = ParseF64(&lane_const_, const_type);
 2828|  93.1k|          const_->set_v128_f64(lane, lane_const_.f64_bits());
 2829|  93.1k|          break;
 2830|   100k|      }
 2831|       |
 2832|   100k|      const_->set_expected_nan(lane, lane_const_.expected_nan());
 2833|   100k|    }
 2834|       |
 2835|   109k|    if (Failed(result)) {
  ------------------
  |  Branch (2835:9): [True: 3.23k, False: 106k]
  ------------------
 2836|  3.23k|      Error(loc, "invalid literal \"%s\"", token.to_string().c_str());
 2837|  3.23k|      return Result::Error;
 2838|  3.23k|    }
 2839|   109k|  }
 2840|       |
 2841|  47.1k|  return Result::Ok;
 2842|  60.2k|}
_ZN4wabt10WastParser8ParseF32EPNS_5ConstENS0_9ConstTypeE:
 2861|   127k|Result WastParser::ParseF32(Const* const_, ConstType const_type) {
 2862|   127k|  ExpectedNan expected;
 2863|   127k|  if (const_type == ConstType::Expectation &&
  ------------------
  |  Branch (2863:7): [True: 0, False: 127k]
  ------------------
 2864|   127k|      Succeeded(ParseExpectedNan(&expected))) {
  ------------------
  |  Branch (2864:7): [True: 0, False: 0]
  ------------------
 2865|      0|    const_->set_f32(expected);
 2866|      0|    return Result::Ok;
 2867|      0|  }
 2868|       |
 2869|   127k|  auto token = Consume();
 2870|   127k|  if (!token.HasLiteral()) {
  ------------------
  |  Branch (2870:7): [True: 613, False: 127k]
  ------------------
 2871|    613|    return Result::Error;
 2872|    613|  }
 2873|       |
 2874|   127k|  auto literal = token.literal();
 2875|   127k|  uint32_t f32_bits;
 2876|   127k|  Result result = ParseFloat(literal.type, literal.text, &f32_bits);
 2877|   127k|  const_->set_f32(f32_bits);
 2878|   127k|  return result;
 2879|   127k|}
_ZN4wabt10WastParser8ParseF64EPNS_5ConstENS0_9ConstTypeE:
 2881|   183k|Result WastParser::ParseF64(Const* const_, ConstType const_type) {
 2882|   183k|  ExpectedNan expected;
 2883|   183k|  if (const_type == ConstType::Expectation &&
  ------------------
  |  Branch (2883:7): [True: 0, False: 183k]
  ------------------
 2884|   183k|      Succeeded(ParseExpectedNan(&expected))) {
  ------------------
  |  Branch (2884:7): [True: 0, False: 0]
  ------------------
 2885|      0|    const_->set_f64(expected);
 2886|      0|    return Result::Ok;
 2887|      0|  }
 2888|       |
 2889|   183k|  auto token = Consume();
 2890|   183k|  if (!token.HasLiteral()) {
  ------------------
  |  Branch (2890:7): [True: 194, False: 183k]
  ------------------
 2891|    194|    return Result::Error;
 2892|    194|  }
 2893|       |
 2894|   183k|  auto literal = token.literal();
 2895|   183k|  uint64_t f64_bits;
 2896|   183k|  Result result = ParseDouble(literal.type, literal.text, &f64_bits);
 2897|   183k|  const_->set_f64(f64_bits);
 2898|   183k|  return result;
 2899|   183k|}
_ZN4wabt10WastParser10ParseConstEPNS_5ConstENS0_9ConstTypeE:
 2901|   329k|Result WastParser::ParseConst(Const* const_, ConstType const_type) {
 2902|   329k|  WABT_TRACE(ParseConst);
 2903|   329k|  Token opcode_token = Consume();
 2904|   329k|  Opcode opcode = opcode_token.opcode();
 2905|   329k|  const_->loc = GetLocation();
 2906|   329k|  Token token = GetToken();
 2907|       |
 2908|       |  // V128 is fully handled by ParseSimdV128Const:
 2909|   329k|  if (opcode != Opcode::V128Const) {
  ------------------
  |  Branch (2909:7): [True: 266k, False: 62.6k]
  ------------------
 2910|   266k|    switch (token.token_type()) {
 2911|  34.4k|      case TokenType::Nat:
  ------------------
  |  Branch (2911:7): [True: 34.4k, False: 232k]
  ------------------
 2912|  36.3k|      case TokenType::Int:
  ------------------
  |  Branch (2912:7): [True: 1.81k, False: 265k]
  ------------------
 2913|   222k|      case TokenType::Float:
  ------------------
  |  Branch (2913:7): [True: 185k, False: 81.1k]
  ------------------
 2914|       |        // OK.
 2915|   222k|        break;
 2916|    234|      case TokenType::NanArithmetic:
  ------------------
  |  Branch (2916:7): [True: 234, False: 266k]
  ------------------
 2917|    800|      case TokenType::NanCanonical:
  ------------------
  |  Branch (2917:7): [True: 566, False: 266k]
  ------------------
 2918|    800|        break;
 2919|  44.0k|      default:
  ------------------
  |  Branch (2919:7): [True: 44.0k, False: 222k]
  ------------------
 2920|  44.0k|        return ErrorExpected({"a numeric literal"}, "123, -45, 6.7e8");
 2921|   266k|    }
 2922|   266k|  }
 2923|       |
 2924|   285k|  Result result;
 2925|   285k|  switch (opcode) {
 2926|  10.9k|    case Opcode::I32Const: {
  ------------------
  |  Branch (2926:5): [True: 10.9k, False: 274k]
  ------------------
 2927|  10.9k|      auto token = Consume();
 2928|  10.9k|      if (!token.HasLiteral()) {
  ------------------
  |  Branch (2928:11): [True: 198, False: 10.7k]
  ------------------
 2929|    198|        result = Result::Error;
 2930|    198|        break;
 2931|    198|      }
 2932|  10.7k|      auto sv = token.literal().text;
 2933|  10.7k|      uint32_t u32;
 2934|  10.7k|      result = ParseInt32(sv, &u32, ParseIntType::SignedAndUnsigned);
 2935|  10.7k|      const_->set_u32(u32);
 2936|  10.7k|      break;
 2937|  10.9k|    }
 2938|       |
 2939|  1.22k|    case Opcode::I64Const: {
  ------------------
  |  Branch (2939:5): [True: 1.22k, False: 284k]
  ------------------
 2940|  1.22k|      auto token = Consume();
 2941|  1.22k|      if (!token.HasLiteral()) {
  ------------------
  |  Branch (2941:11): [True: 230, False: 991]
  ------------------
 2942|    230|        result = Result::Error;
 2943|    230|        break;
 2944|    230|      }
 2945|    991|      auto sv = token.literal().text;
 2946|    991|      uint64_t u64;
 2947|    991|      result = ParseInt64(sv, &u64, ParseIntType::SignedAndUnsigned);
 2948|    991|      const_->set_u64(u64);
 2949|    991|      break;
 2950|  1.22k|    }
 2951|       |
 2952|   120k|    case Opcode::F32Const:
  ------------------
  |  Branch (2952:5): [True: 120k, False: 164k]
  ------------------
 2953|   120k|      result = ParseF32(const_, const_type);
 2954|   120k|      break;
 2955|       |
 2956|  90.0k|    case Opcode::F64Const:
  ------------------
  |  Branch (2956:5): [True: 90.0k, False: 195k]
  ------------------
 2957|  90.0k|      result = ParseF64(const_, const_type);
 2958|  90.0k|      break;
 2959|       |
 2960|  62.6k|    case Opcode::V128Const:
  ------------------
  |  Branch (2960:5): [True: 62.6k, False: 222k]
  ------------------
 2961|  62.6k|      ErrorUnlessOpcodeEnabled(opcode_token);
 2962|       |      // Parse V128 Simd Const (16 bytes).
 2963|  62.6k|      result = ParseSimdV128Const(const_, token.token_type(), const_type);
 2964|       |      // ParseSimdV128Const report error already, just return here if parser get
 2965|       |      // errors.
 2966|  62.6k|      if (Failed(result)) {
  ------------------
  |  Branch (2966:11): [True: 15.4k, False: 47.1k]
  ------------------
 2967|  15.4k|        return Result::Error;
 2968|  15.4k|      }
 2969|  47.1k|      break;
 2970|       |
 2971|  47.1k|    default:
  ------------------
  |  Branch (2971:5): [True: 0, False: 285k]
  ------------------
 2972|      0|      assert(!"ParseConst called with invalid opcode");
 2973|      0|      return Result::Error;
 2974|   285k|  }
 2975|       |
 2976|   269k|  if (Failed(result)) {
  ------------------
  |  Branch (2976:7): [True: 24.9k, False: 244k]
  ------------------
 2977|  24.9k|    Error(const_->loc, "invalid literal \"%s\"", token.to_string().c_str());
 2978|       |    // Return if parser get errors.
 2979|  24.9k|    return Result::Error;
 2980|  24.9k|  }
 2981|       |
 2982|   244k|  return Result::Ok;
 2983|   269k|}
_ZN4wabt10WastParser15ParseBlockInstrEPNSt3__110unique_ptrINS_4ExprENS1_14default_deleteIS3_EEEE:
 3065|   164k|Result WastParser::ParseBlockInstr(std::unique_ptr<Expr>* out_expr) {
 3066|   164k|  WABT_TRACE(ParseBlockInstr);
 3067|   164k|  Location loc = GetLocation();
 3068|       |
 3069|   164k|  switch (Peek()) {
 3070|  1.30k|    case TokenType::Block: {
  ------------------
  |  Branch (3070:5): [True: 1.30k, False: 162k]
  ------------------
 3071|  1.30k|      Consume();
 3072|  1.30k|      auto expr = std::make_unique<BlockExpr>(loc);
 3073|  1.30k|      CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  1.30k|  do {                              \
  |  |   56|  1.30k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 1.30k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  1.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3074|  1.30k|      CHECK_RESULT(ParseBlock(&expr->block));
  ------------------
  |  |   55|  1.30k|  do {                              \
  |  |   56|  1.30k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 346, False: 960]
  |  |  ------------------
  |  |   57|    346|      return ::wabt::Result::Error; \
  |  |   58|    346|    }                               \
  |  |   59|  1.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3075|    960|      EXPECT(End);
  ------------------
  |  |   31|    960|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    960|  do {                              \
  |  |  |  |   56|    960|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 352, False: 608]
  |  |  |  |  ------------------
  |  |  |  |   57|    352|      return ::wabt::Result::Error; \
  |  |  |  |   58|    352|    }                               \
  |  |  |  |   59|    960|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3076|    608|      CHECK_RESULT(ParseEndLabelOpt(expr->block.label));
  ------------------
  |  |   55|    608|  do {                              \
  |  |   56|    608|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 608]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    608|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3077|    608|      *out_expr = std::move(expr);
 3078|    608|      break;
 3079|    608|    }
 3080|       |
 3081|  2.11k|    case TokenType::Loop: {
  ------------------
  |  Branch (3081:5): [True: 2.11k, False: 161k]
  ------------------
 3082|  2.11k|      Consume();
 3083|  2.11k|      auto expr = std::make_unique<LoopExpr>(loc);
 3084|  2.11k|      CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  2.11k|  do {                              \
  |  |   56|  2.11k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.11k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.11k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3085|  2.11k|      CHECK_RESULT(ParseBlock(&expr->block));
  ------------------
  |  |   55|  2.11k|  do {                              \
  |  |   56|  2.11k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 880, False: 1.23k]
  |  |  ------------------
  |  |   57|    880|      return ::wabt::Result::Error; \
  |  |   58|    880|    }                               \
  |  |   59|  2.11k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3086|  1.23k|      EXPECT(End);
  ------------------
  |  |   31|  1.23k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  1.23k|  do {                              \
  |  |  |  |   56|  1.23k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 1.04k, False: 194]
  |  |  |  |  ------------------
  |  |  |  |   57|  1.04k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  1.04k|    }                               \
  |  |  |  |   59|  1.23k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3087|    194|      CHECK_RESULT(ParseEndLabelOpt(expr->block.label));
  ------------------
  |  |   55|    194|  do {                              \
  |  |   56|    194|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 194]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    194|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3088|    194|      *out_expr = std::move(expr);
 3089|    194|      break;
 3090|    194|    }
 3091|       |
 3092|   104k|    case TokenType::If: {
  ------------------
  |  Branch (3092:5): [True: 104k, False: 59.2k]
  ------------------
 3093|   104k|      Consume();
 3094|   104k|      auto expr = std::make_unique<IfExpr>(loc);
 3095|   104k|      CHECK_RESULT(ParseLabelOpt(&expr->true_.label));
  ------------------
  |  |   55|   104k|  do {                              \
  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 104k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|   104k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3096|   104k|      CHECK_RESULT(ParseBlock(&expr->true_));
  ------------------
  |  |   55|   104k|  do {                              \
  |  |   56|   104k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 89.0k, False: 15.7k]
  |  |  ------------------
  |  |   57|  89.0k|      return ::wabt::Result::Error; \
  |  |   58|  89.0k|    }                               \
  |  |   59|   104k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3097|  15.7k|      if (Match(TokenType::Else)) {
  ------------------
  |  Branch (3097:11): [True: 3.08k, False: 12.6k]
  ------------------
 3098|  3.08k|        CHECK_RESULT(ParseEndLabelOpt(expr->true_.label));
  ------------------
  |  |   55|  3.08k|  do {                              \
  |  |   56|  3.08k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 3.08k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  3.08k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3099|  3.08k|        CHECK_RESULT(ParseTerminatingInstrList(&expr->false_));
  ------------------
  |  |   55|  3.08k|  do {                              \
  |  |   56|  3.08k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.16k, False: 922]
  |  |  ------------------
  |  |   57|  2.16k|      return ::wabt::Result::Error; \
  |  |   58|  2.16k|    }                               \
  |  |   59|  3.08k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3100|    922|        expr->false_end_loc = GetLocation();
 3101|    922|      }
 3102|  13.6k|      EXPECT(End);
  ------------------
  |  |   31|  13.6k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  13.6k|  do {                              \
  |  |  |  |   56|  13.6k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 8.51k, False: 5.09k]
  |  |  |  |  ------------------
  |  |  |  |   57|  8.51k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  8.51k|    }                               \
  |  |  |  |   59|  13.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3103|  5.09k|      CHECK_RESULT(ParseEndLabelOpt(expr->true_.label));
  ------------------
  |  |   55|  5.09k|  do {                              \
  |  |   56|  5.09k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 5.09k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  5.09k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3104|  5.09k|      *out_expr = std::move(expr);
 3105|  5.09k|      break;
 3106|  5.09k|    }
 3107|       |
 3108|  52.8k|    case TokenType::Try: {
  ------------------
  |  Branch (3108:5): [True: 52.8k, False: 111k]
  ------------------
 3109|  52.8k|      ErrorUnlessOpcodeEnabled(Consume());
 3110|  52.8k|      auto expr = std::make_unique<TryExpr>(loc);
 3111|  52.8k|      CatchVector catches;
 3112|  52.8k|      CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  52.8k|  do {                              \
  |  |   56|  52.8k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 52.8k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  52.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3113|  52.8k|      CHECK_RESULT(ParseBlock(&expr->block));
  ------------------
  |  |   55|  52.8k|  do {                              \
  |  |   56|  52.8k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 4.21k, False: 48.6k]
  |  |  ------------------
  |  |   57|  4.21k|      return ::wabt::Result::Error; \
  |  |   58|  4.21k|    }                               \
  |  |   59|  52.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3114|  48.6k|      if (IsCatch(Peek())) {
  ------------------
  |  Branch (3114:11): [True: 1.94k, False: 46.7k]
  ------------------
 3115|  1.94k|        CHECK_RESULT(ParseCatchInstrList(&expr->catches));
  ------------------
  |  |   55|  1.94k|  do {                              \
  |  |   56|  1.94k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.05k, False: 890]
  |  |  ------------------
  |  |   57|  1.05k|      return ::wabt::Result::Error; \
  |  |   58|  1.05k|    }                               \
  |  |   59|  1.94k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3116|    890|        expr->kind = TryKind::Catch;
 3117|  46.7k|      } else if (PeekMatch(TokenType::Delegate)) {
  ------------------
  |  Branch (3117:18): [True: 0, False: 46.7k]
  ------------------
 3118|      0|        Consume();
 3119|      0|        Var var;
 3120|      0|        CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3121|      0|        expr->delegate_target = var;
 3122|      0|        expr->kind = TryKind::Delegate;
 3123|      0|      }
 3124|  47.6k|      CHECK_RESULT(ErrorIfLpar({"a valid try clause"}));
  ------------------
  |  |   55|  47.6k|  do {                              \
  |  |   56|  47.6k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 5.45k, False: 42.1k]
  |  |  ------------------
  |  |   57|  5.45k|      return ::wabt::Result::Error; \
  |  |   58|  5.45k|    }                               \
  |  |   59|  47.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3125|  42.1k|      expr->block.end_loc = GetLocation();
 3126|  42.1k|      if (expr->kind != TryKind::Delegate) {
  ------------------
  |  Branch (3126:11): [True: 42.1k, False: 0]
  ------------------
 3127|  42.1k|        EXPECT(End);
  ------------------
  |  |   31|  42.1k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  42.1k|  do {                              \
  |  |  |  |   56|  42.1k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 23.1k, False: 18.9k]
  |  |  |  |  ------------------
  |  |  |  |   57|  23.1k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  23.1k|    }                               \
  |  |  |  |   59|  42.1k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3128|  42.1k|      }
 3129|  18.9k|      CHECK_RESULT(ParseEndLabelOpt(expr->block.label));
  ------------------
  |  |   55|  18.9k|  do {                              \
  |  |   56|  18.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 18.9k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  18.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3130|  18.9k|      *out_expr = std::move(expr);
 3131|  18.9k|      break;
 3132|  18.9k|    }
 3133|       |
 3134|  2.97k|    case TokenType::TryTable: {
  ------------------
  |  Branch (3134:5): [True: 2.97k, False: 161k]
  ------------------
 3135|  2.97k|      ErrorUnlessOpcodeEnabled(Consume());
 3136|  2.97k|      auto expr = std::make_unique<TryTableExpr>(loc);
 3137|  2.97k|      CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  2.97k|  do {                              \
  |  |   56|  2.97k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 2.97k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  2.97k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3138|  2.97k|      CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl));
  ------------------
  |  |   55|  2.97k|  do {                              \
  |  |   56|  2.97k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 768, False: 2.20k]
  |  |  ------------------
  |  |   57|    768|      return ::wabt::Result::Error; \
  |  |   58|    768|    }                               \
  |  |   59|  2.97k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3139|  2.20k|      CHECK_RESULT(ParseTryTableCatches(&expr->catches));
  ------------------
  |  |   55|  2.20k|  do {                              \
  |  |   56|  2.20k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 933, False: 1.27k]
  |  |  ------------------
  |  |   57|    933|      return ::wabt::Result::Error; \
  |  |   58|    933|    }                               \
  |  |   59|  2.20k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3140|  1.27k|      CHECK_RESULT(ParseInstrList(&expr->block.exprs));
  ------------------
  |  |   55|  1.27k|  do {                              \
  |  |   56|  1.27k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 526, False: 745]
  |  |  ------------------
  |  |   57|    526|      return ::wabt::Result::Error; \
  |  |   58|    526|    }                               \
  |  |   59|  1.27k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3141|    745|      EXPECT(End);
  ------------------
  |  |   31|    745|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    745|  do {                              \
  |  |  |  |   56|    745|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 551, False: 194]
  |  |  |  |  ------------------
  |  |  |  |   57|    551|      return ::wabt::Result::Error; \
  |  |  |  |   58|    551|    }                               \
  |  |  |  |   59|    745|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3142|    194|      CHECK_RESULT(ParseEndLabelOpt(expr->block.label));
  ------------------
  |  |   55|    194|  do {                              \
  |  |   56|    194|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 194]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    194|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3143|    194|      *out_expr = std::move(expr);
 3144|    194|      break;
 3145|    194|    }
 3146|       |
 3147|      0|    default:
  ------------------
  |  Branch (3147:5): [True: 0, False: 164k]
  ------------------
 3148|      0|      assert(
 3149|      0|          !"ParseBlockInstr should only be called when IsBlockInstr() is true");
 3150|      0|      return Result::Error;
 3151|   164k|  }
 3152|       |
 3153|  25.0k|  return Result::Ok;
 3154|   164k|}
_ZN4wabt10WastParser13ParseLabelOptEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3156|   338k|Result WastParser::ParseLabelOpt(std::string* out_label) {
 3157|   338k|  WABT_TRACE(ParseLabelOpt);
 3158|   338k|  if (PeekMatch(TokenType::Var)) {
  ------------------
  |  Branch (3158:7): [True: 13.5k, False: 325k]
  ------------------
 3159|  13.5k|    *out_label = std::string(Consume().text());
 3160|   325k|  } else {
 3161|   325k|    out_label->clear();
 3162|   325k|  }
 3163|   338k|  return Result::Ok;
 3164|   338k|}
_ZN4wabt10WastParser16ParseEndLabelOptERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 3166|  28.1k|Result WastParser::ParseEndLabelOpt(const std::string& begin_label) {
 3167|  28.1k|  WABT_TRACE(ParseEndLabelOpt);
 3168|  28.1k|  Location loc = GetLocation();
 3169|  28.1k|  std::string end_label;
 3170|  28.1k|  CHECK_RESULT(ParseLabelOpt(&end_label));
  ------------------
  |  |   55|  28.1k|  do {                              \
  |  |   56|  28.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 28.1k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  28.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3171|  28.1k|  if (!end_label.empty()) {
  ------------------
  |  Branch (3171:7): [True: 3.14k, False: 25.0k]
  ------------------
 3172|  3.14k|    if (begin_label.empty()) {
  ------------------
  |  Branch (3172:9): [True: 1.46k, False: 1.67k]
  ------------------
 3173|  1.46k|      Error(loc, "unexpected label \"%s\"", end_label.c_str());
 3174|  1.67k|    } else if (begin_label != end_label) {
  ------------------
  |  Branch (3174:16): [True: 1.46k, False: 209]
  ------------------
 3175|  1.46k|      Error(loc, "mismatching label \"%s\" != \"%s\"", begin_label.c_str(),
 3176|  1.46k|            end_label.c_str());
 3177|  1.46k|    }
 3178|  3.14k|  }
 3179|  28.1k|  return Result::Ok;
 3180|  28.1k|}
_ZN4wabt10WastParser21ParseBlockDeclarationEPNS_15FuncDeclarationE:
 3182|   310k|Result WastParser::ParseBlockDeclaration(BlockDeclaration* decl) {
 3183|   310k|  WABT_TRACE(ParseBlockDeclaration);
 3184|   310k|  CHECK_RESULT(ParseTypeUseOpt(decl));
  ------------------
  |  |   55|   310k|  do {                              \
  |  |   56|   310k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 6.33k, False: 304k]
  |  |  ------------------
  |  |   57|  6.33k|      return ::wabt::Result::Error; \
  |  |   58|  6.33k|    }                               \
  |  |   59|   310k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3185|   304k|  CHECK_RESULT(ParseUnboundFuncSignature(&decl->sig));
  ------------------
  |  |   55|   304k|  do {                              \
  |  |   56|   304k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.51k, False: 301k]
  |  |  ------------------
  |  |   57|  2.51k|      return ::wabt::Result::Error; \
  |  |   58|  2.51k|    }                               \
  |  |   59|   304k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3186|   301k|  return Result::Ok;
 3187|   304k|}
_ZN4wabt10WastParser10ParseBlockEPNS_5BlockE:
 3189|   241k|Result WastParser::ParseBlock(Block* block) {
 3190|   241k|  WABT_TRACE(ParseBlock);
 3191|   241k|  CHECK_RESULT(ParseBlockDeclaration(&block->decl));
  ------------------
  |  |   55|   241k|  do {                              \
  |  |   56|   241k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.05k, False: 238k]
  |  |  ------------------
  |  |   57|  3.05k|      return ::wabt::Result::Error; \
  |  |   58|  3.05k|    }                               \
  |  |   59|   241k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3192|   238k|  CHECK_RESULT(ParseInstrList(&block->exprs));
  ------------------
  |  |   55|   238k|  do {                              \
  |  |   56|   238k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 103k, False: 135k]
  |  |  ------------------
  |  |   57|   103k|      return ::wabt::Result::Error; \
  |  |   58|   103k|    }                               \
  |  |   59|   238k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3193|   135k|  block->end_loc = GetLocation();
 3194|   135k|  return Result::Ok;
 3195|   238k|}
_ZN4wabt10WastParser13ParseExprListEPNS_14intrusive_listINS_4ExprEEE:
 3197|   474k|Result WastParser::ParseExprList(ExprList* exprs) {
 3198|   474k|  WABT_TRACE(ParseExprList);
 3199|   474k|  ExprList new_exprs;
 3200|   782k|  while (PeekMatchExpr()) {
  ------------------
  |  Branch (3200:10): [True: 398k, False: 384k]
  ------------------
 3201|   398k|    if (Succeeded(ParseExpr(&new_exprs))) {
  ------------------
  |  Branch (3201:9): [True: 150k, False: 248k]
  ------------------
 3202|   150k|      exprs->splice(exprs->end(), new_exprs);
 3203|   248k|    } else {
 3204|   248k|      CHECK_RESULT(Synchronize(IsExpr));
  ------------------
  |  |   55|   248k|  do {                              \
  |  |   56|   248k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 90.2k, False: 158k]
  |  |  ------------------
  |  |   57|  90.2k|      return ::wabt::Result::Error; \
  |  |   58|  90.2k|    }                               \
  |  |   59|   248k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3205|   248k|    }
 3206|   398k|  }
 3207|   384k|  return Result::Ok;
 3208|   474k|}
_ZN4wabt10WastParser9ParseExprEPNS_14intrusive_listINS_4ExprEEE:
 3210|   699k|Result WastParser::ParseExpr(ExprList* exprs) {
 3211|   699k|  WABT_TRACE(ParseExpr);
 3212|   699k|  if (!PeekMatch(TokenType::Lpar)) {
  ------------------
  |  Branch (3212:7): [True: 0, False: 699k]
  ------------------
 3213|      0|    return Result::Error;
 3214|      0|  }
 3215|       |
 3216|   699k|  if (IsPlainInstr(Peek(1))) {
  ------------------
  |  Branch (3216:7): [True: 553k, False: 146k]
  ------------------
 3217|   553k|    Consume();
 3218|   553k|    std::unique_ptr<Expr> expr;
 3219|   553k|    CHECK_RESULT(ParsePlainInstr(&expr));
  ------------------
  |  |   55|   553k|  do {                              \
  |  |   56|   553k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 78.8k, False: 474k]
  |  |  ------------------
  |  |   57|  78.8k|      return ::wabt::Result::Error; \
  |  |   58|  78.8k|    }                               \
  |  |   59|   553k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3220|   474k|    CHECK_RESULT(ParseExprList(exprs));
  ------------------
  |  |   55|   474k|  do {                              \
  |  |   56|   474k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 90.2k, False: 384k]
  |  |  ------------------
  |  |   57|  90.2k|      return ::wabt::Result::Error; \
  |  |   58|  90.2k|    }                               \
  |  |   59|   474k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3221|   384k|    CHECK_RESULT(ErrorIfLpar({"an expr"}));
  ------------------
  |  |   55|   384k|  do {                              \
  |  |   56|   384k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 116k, False: 268k]
  |  |  ------------------
  |  |   57|   116k|      return ::wabt::Result::Error; \
  |  |   58|   116k|    }                               \
  |  |   59|   384k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3222|   268k|    exprs->push_back(std::move(expr));
 3223|   268k|  } else {
 3224|   146k|    Location loc = GetLocation();
 3225|       |
 3226|   146k|    switch (Peek(1)) {
 3227|  5.29k|      case TokenType::Block: {
  ------------------
  |  Branch (3227:7): [True: 5.29k, False: 141k]
  ------------------
 3228|  5.29k|        Consume();
 3229|  5.29k|        Consume();
 3230|  5.29k|        auto expr = std::make_unique<BlockExpr>(loc);
 3231|  5.29k|        CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  5.29k|  do {                              \
  |  |   56|  5.29k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 5.29k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  5.29k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3232|  5.29k|        CHECK_RESULT(ParseBlock(&expr->block));
  ------------------
  |  |   55|  5.29k|  do {                              \
  |  |   56|  5.29k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 367, False: 4.92k]
  |  |  ------------------
  |  |   57|    367|      return ::wabt::Result::Error; \
  |  |   58|    367|    }                               \
  |  |   59|  5.29k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3233|  4.92k|        exprs->push_back(std::move(expr));
 3234|  4.92k|        break;
 3235|  5.29k|      }
 3236|       |
 3237|  74.9k|      case TokenType::Loop: {
  ------------------
  |  Branch (3237:7): [True: 74.9k, False: 71.3k]
  ------------------
 3238|  74.9k|        Consume();
 3239|  74.9k|        Consume();
 3240|  74.9k|        auto expr = std::make_unique<LoopExpr>(loc);
 3241|  74.9k|        CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  74.9k|  do {                              \
  |  |   56|  74.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 74.9k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  74.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3242|  74.9k|        CHECK_RESULT(ParseBlock(&expr->block));
  ------------------
  |  |   55|  74.9k|  do {                              \
  |  |   56|  74.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 11.5k, False: 63.4k]
  |  |  ------------------
  |  |   57|  11.5k|      return ::wabt::Result::Error; \
  |  |   58|  11.5k|    }                               \
  |  |   59|  74.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3243|  63.4k|        exprs->push_back(std::move(expr));
 3244|  63.4k|        break;
 3245|  74.9k|      }
 3246|       |
 3247|  35.1k|      case TokenType::If: {
  ------------------
  |  Branch (3247:7): [True: 35.1k, False: 111k]
  ------------------
 3248|  35.1k|        Consume();
 3249|  35.1k|        Consume();
 3250|  35.1k|        auto expr = std::make_unique<IfExpr>(loc);
 3251|       |
 3252|  35.1k|        CHECK_RESULT(ParseLabelOpt(&expr->true_.label));
  ------------------
  |  |   55|  35.1k|  do {                              \
  |  |   56|  35.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 35.1k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  35.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3253|  35.1k|        CHECK_RESULT(ParseBlockDeclaration(&expr->true_.decl));
  ------------------
  |  |   55|  35.1k|  do {                              \
  |  |   56|  35.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.25k, False: 31.8k]
  |  |  ------------------
  |  |   57|  3.25k|      return ::wabt::Result::Error; \
  |  |   58|  3.25k|    }                               \
  |  |   59|  35.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3254|       |
 3255|  52.6k|        while (PeekMatchExpr()) {
  ------------------
  |  Branch (3255:16): [True: 22.9k, False: 29.7k]
  ------------------
 3256|  22.9k|          ExprList cond;
 3257|  22.9k|          CHECK_RESULT(ParseExpr(&cond));
  ------------------
  |  |   55|  22.9k|  do {                              \
  |  |   56|  22.9k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.16k, False: 20.7k]
  |  |  ------------------
  |  |   57|  2.16k|      return ::wabt::Result::Error; \
  |  |   58|  2.16k|    }                               \
  |  |   59|  22.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3258|  20.7k|          exprs->splice(exprs->end(), cond);
 3259|  20.7k|        }
 3260|       |
 3261|  29.7k|        EXPECT(Lpar);
  ------------------
  |  |   31|  29.7k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  29.7k|  do {                              \
  |  |  |  |   56|  29.7k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 2.65k, False: 27.0k]
  |  |  |  |  ------------------
  |  |  |  |   57|  2.65k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  2.65k|    }                               \
  |  |  |  |   59|  29.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3262|  27.0k|        if (!Match(TokenType::Then)) {
  ------------------
  |  Branch (3262:13): [True: 23.5k, False: 3.46k]
  ------------------
 3263|  23.5k|          return ErrorExpected({"then block"}, "(then ...)");
 3264|  23.5k|        }
 3265|       |
 3266|  3.46k|        CHECK_RESULT(ParseTerminatingInstrList(&expr->true_.exprs));
  ------------------
  |  |   55|  3.46k|  do {                              \
  |  |   56|  3.46k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 877, False: 2.58k]
  |  |  ------------------
  |  |   57|    877|      return ::wabt::Result::Error; \
  |  |   58|    877|    }                               \
  |  |   59|  3.46k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3267|  2.58k|        expr->true_.end_loc = GetLocation();
 3268|  2.58k|        EXPECT(Rpar);
  ------------------
  |  |   31|  2.58k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  2.58k|  do {                              \
  |  |  |  |   56|  2.58k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 280, False: 2.30k]
  |  |  |  |  ------------------
  |  |  |  |   57|    280|      return ::wabt::Result::Error; \
  |  |  |  |   58|    280|    }                               \
  |  |  |  |   59|  2.58k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3269|       |
 3270|  2.30k|        if (MatchLpar(TokenType::Else)) {
  ------------------
  |  Branch (3270:13): [True: 738, False: 1.57k]
  ------------------
 3271|    738|          CHECK_RESULT(ParseTerminatingInstrList(&expr->false_));
  ------------------
  |  |   55|    738|  do {                              \
  |  |   56|    738|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 204, False: 534]
  |  |  ------------------
  |  |   57|    204|      return ::wabt::Result::Error; \
  |  |   58|    204|    }                               \
  |  |   59|    738|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3272|    534|          EXPECT(Rpar);
  ------------------
  |  |   31|    534|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    534|  do {                              \
  |  |  |  |   56|    534|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 328, False: 206]
  |  |  |  |  ------------------
  |  |  |  |   57|    328|      return ::wabt::Result::Error; \
  |  |  |  |   58|    328|    }                               \
  |  |  |  |   59|    534|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3273|    534|        }
 3274|  1.77k|        expr->false_end_loc = GetLocation();
 3275|       |
 3276|  1.77k|        exprs->push_back(std::move(expr));
 3277|  1.77k|        break;
 3278|  2.30k|      }
 3279|       |
 3280|  26.2k|      case TokenType::Try: {
  ------------------
  |  Branch (3280:7): [True: 26.2k, False: 120k]
  ------------------
 3281|  26.2k|        Consume();
 3282|  26.2k|        ErrorUnlessOpcodeEnabled(Consume());
 3283|       |
 3284|  26.2k|        auto expr = std::make_unique<TryExpr>(loc);
 3285|  26.2k|        CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  26.2k|  do {                              \
  |  |   56|  26.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 26.2k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  26.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3286|  26.2k|        CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl));
  ------------------
  |  |   55|  26.2k|  do {                              \
  |  |   56|  26.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.00k, False: 25.2k]
  |  |  ------------------
  |  |   57|  1.00k|      return ::wabt::Result::Error; \
  |  |   58|  1.00k|    }                               \
  |  |   59|  26.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3287|  25.2k|        EXPECT(Lpar);
  ------------------
  |  |   31|  25.2k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  25.2k|  do {                              \
  |  |  |  |   56|  25.2k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 1.69k, False: 23.5k]
  |  |  |  |  ------------------
  |  |  |  |   57|  1.69k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  1.69k|    }                               \
  |  |  |  |   59|  25.2k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3288|  23.5k|        EXPECT(Do);
  ------------------
  |  |   31|  23.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  23.5k|  do {                              \
  |  |  |  |   56|  23.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 3.80k, False: 19.7k]
  |  |  |  |  ------------------
  |  |  |  |   57|  3.80k|      return ::wabt::Result::Error; \
  |  |  |  |   58|  3.80k|    }                               \
  |  |  |  |   59|  23.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3289|  19.7k|        CHECK_RESULT(ParseInstrList(&expr->block.exprs));
  ------------------
  |  |   55|  19.7k|  do {                              \
  |  |   56|  19.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 226, False: 19.5k]
  |  |  ------------------
  |  |   57|    226|      return ::wabt::Result::Error; \
  |  |   58|    226|    }                               \
  |  |   59|  19.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3290|  19.5k|        EXPECT(Rpar);
  ------------------
  |  |   31|  19.5k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  19.5k|  do {                              \
  |  |  |  |   56|  19.5k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 359, False: 19.1k]
  |  |  |  |  ------------------
  |  |  |  |   57|    359|      return ::wabt::Result::Error; \
  |  |  |  |   58|    359|    }                               \
  |  |  |  |   59|  19.5k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3291|  19.1k|        if (PeekMatch(TokenType::Lpar)) {
  ------------------
  |  Branch (3291:13): [True: 18.7k, False: 415]
  ------------------
 3292|  18.7k|          Consume();
 3293|  18.7k|          TokenType type = Peek();
 3294|  18.7k|          switch (type) {
 3295|  2.53k|            case TokenType::Catch:
  ------------------
  |  Branch (3295:13): [True: 2.53k, False: 16.2k]
  ------------------
 3296|  12.8k|            case TokenType::CatchAll:
  ------------------
  |  Branch (3296:13): [True: 10.2k, False: 8.48k]
  ------------------
 3297|  12.8k|              CHECK_RESULT(ParseCatchExprList(&expr->catches));
  ------------------
  |  |   55|  12.8k|  do {                              \
  |  |   56|  12.8k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 2.41k, False: 10.4k]
  |  |  ------------------
  |  |   57|  2.41k|      return ::wabt::Result::Error; \
  |  |   58|  2.41k|    }                               \
  |  |   59|  12.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3298|  10.4k|              expr->kind = TryKind::Catch;
 3299|  10.4k|              break;
 3300|      0|            case TokenType::Delegate: {
  ------------------
  |  Branch (3300:13): [True: 0, False: 18.7k]
  ------------------
 3301|      0|              Consume();
 3302|      0|              Var var;
 3303|      0|              CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3304|      0|              expr->delegate_target = var;
 3305|      0|              expr->kind = TryKind::Delegate;
 3306|      0|              EXPECT(Rpar);
  ------------------
  |  |   31|      0|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|      0|  do {                              \
  |  |  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3307|      0|              break;
 3308|      0|            }
 3309|  5.94k|            default:
  ------------------
  |  Branch (3309:13): [True: 5.94k, False: 12.8k]
  ------------------
 3310|  5.94k|              ErrorExpected({"catch", "catch_all", "delegate"});
 3311|  5.94k|              break;
 3312|  18.7k|          }
 3313|  18.7k|        }
 3314|  16.7k|        CHECK_RESULT(ErrorIfLpar({"a valid try clause"}));
  ------------------
  |  |   55|  16.7k|  do {                              \
  |  |   56|  16.7k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 5.22k, False: 11.5k]
  |  |  ------------------
  |  |   57|  5.22k|      return ::wabt::Result::Error; \
  |  |   58|  5.22k|    }                               \
  |  |   59|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3315|  11.5k|        expr->block.end_loc = GetLocation();
 3316|  11.5k|        exprs->push_back(std::move(expr));
 3317|  11.5k|        break;
 3318|  16.7k|      }
 3319|       |
 3320|  4.62k|      case TokenType::TryTable: {
  ------------------
  |  Branch (3320:7): [True: 4.62k, False: 141k]
  ------------------
 3321|  4.62k|        Consume();
 3322|  4.62k|        ErrorUnlessOpcodeEnabled(Consume());
 3323|  4.62k|        auto expr = std::make_unique<TryTableExpr>(loc);
 3324|  4.62k|        CHECK_RESULT(ParseLabelOpt(&expr->block.label));
  ------------------
  |  |   55|  4.62k|  do {                              \
  |  |   56|  4.62k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 4.62k]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|  4.62k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3325|  4.62k|        CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl));
  ------------------
  |  |   55|  4.62k|  do {                              \
  |  |   56|  4.62k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 769, False: 3.85k]
  |  |  ------------------
  |  |   57|    769|      return ::wabt::Result::Error; \
  |  |   58|    769|    }                               \
  |  |   59|  4.62k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3326|  3.85k|        CHECK_RESULT(ParseTryTableCatches(&expr->catches));
  ------------------
  |  |   55|  3.85k|  do {                              \
  |  |   56|  3.85k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 648, False: 3.20k]
  |  |  ------------------
  |  |   57|    648|      return ::wabt::Result::Error; \
  |  |   58|    648|    }                               \
  |  |   59|  3.85k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3327|  3.20k|        CHECK_RESULT(ParseInstrList(&expr->block.exprs));
  ------------------
  |  |   55|  3.20k|  do {                              \
  |  |   56|  3.20k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 481, False: 2.72k]
  |  |  ------------------
  |  |   57|    481|      return ::wabt::Result::Error; \
  |  |   58|    481|    }                               \
  |  |   59|  3.20k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3328|  2.72k|        expr->block.end_loc = GetLocation();
 3329|  2.72k|        exprs->push_back(std::move(expr));
 3330|  2.72k|        break;
 3331|  3.20k|      }
 3332|       |
 3333|      0|      default:
  ------------------
  |  Branch (3333:7): [True: 0, False: 146k]
  ------------------
 3334|      0|        assert(!"ParseExpr should only be called when IsExpr() is true");
 3335|      0|        return Result::Error;
 3336|   146k|    }
 3337|   146k|  }
 3338|       |
 3339|   352k|  EXPECT(Rpar);
  ------------------
  |  |   31|   352k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|   352k|  do {                              \
  |  |  |  |   56|   352k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 156k, False: 196k]
  |  |  |  |  ------------------
  |  |  |  |   57|   156k|      return ::wabt::Result::Error; \
  |  |  |  |   58|   156k|    }                               \
  |  |  |  |   59|   352k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3340|   196k|  return Result::Ok;
 3341|   352k|}
_ZN4wabt10WastParser19ParseCatchInstrListEPNSt3__16vectorINS_5CatchENS1_9allocatorIS3_EEEE:
 3343|  1.94k|Result WastParser::ParseCatchInstrList(CatchVector* catches) {
 3344|  1.94k|  WABT_TRACE(ParseCatchInstrList);
 3345|  1.94k|  bool parsedCatch = false;
 3346|  1.94k|  bool parsedCatchAll = false;
 3347|       |
 3348|  4.75k|  while (IsCatch(Peek())) {
  ------------------
  |  Branch (3348:10): [True: 3.86k, False: 890]
  ------------------
 3349|  3.86k|    Catch catch_(GetLocation());
 3350|       |
 3351|  3.86k|    auto token = Consume();
 3352|  3.86k|    if (token.token_type() == TokenType::Catch) {
  ------------------
  |  Branch (3352:9): [True: 3.17k, False: 684]
  ------------------
 3353|  3.17k|      CHECK_RESULT(ParseVar(&catch_.var));
  ------------------
  |  |   55|  3.17k|  do {                              \
  |  |   56|  3.17k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 214, False: 2.96k]
  |  |  ------------------
  |  |   57|    214|      return ::wabt::Result::Error; \
  |  |   58|    214|    }                               \
  |  |   59|  3.17k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3354|  3.17k|    } else {
 3355|    684|      if (parsedCatchAll) {
  ------------------
  |  Branch (3355:11): [True: 194, False: 490]
  ------------------
 3356|    194|        Error(token.loc, "multiple catch_all clauses not allowed");
 3357|    194|        return Result::Error;
 3358|    194|      }
 3359|    490|      parsedCatchAll = true;
 3360|    490|    }
 3361|       |
 3362|  3.45k|    CHECK_RESULT(ParseInstrList(&catch_.exprs));
  ------------------
  |  |   55|  3.45k|  do {                              \
  |  |   56|  3.45k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 651, False: 2.80k]
  |  |  ------------------
  |  |   57|    651|      return ::wabt::Result::Error; \
  |  |   58|    651|    }                               \
  |  |   59|  3.45k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3363|  2.80k|    catches->push_back(std::move(catch_));
 3364|  2.80k|    parsedCatch = true;
 3365|  2.80k|  }
 3366|       |
 3367|    890|  if (!parsedCatch) {
  ------------------
  |  Branch (3367:7): [True: 0, False: 890]
  ------------------
 3368|      0|    return ErrorExpected({"catch"});
 3369|      0|  }
 3370|       |
 3371|    890|  return Result::Ok;
 3372|    890|}
_ZN4wabt10WastParser18ParseCatchExprListEPNSt3__16vectorINS_5CatchENS1_9allocatorIS3_EEEE:
 3374|  12.8k|Result WastParser::ParseCatchExprList(CatchVector* catches) {
 3375|  12.8k|  WABT_TRACE(ParseCatchExprList);
 3376|  12.8k|  bool parsedCatchAll = false;
 3377|       |
 3378|  14.2k|  do {
 3379|  14.2k|    Catch catch_(GetLocation());
 3380|       |
 3381|  14.2k|    auto token = Consume();
 3382|  14.2k|    if (token.token_type() == TokenType::Catch) {
  ------------------
  |  Branch (3382:9): [True: 3.78k, False: 10.4k]
  ------------------
 3383|  3.78k|      CHECK_RESULT(ParseVar(&catch_.var));
  ------------------
  |  |   55|  3.78k|  do {                              \
  |  |   56|  3.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 233, False: 3.55k]
  |  |  ------------------
  |  |   57|    233|      return ::wabt::Result::Error; \
  |  |   58|    233|    }                               \
  |  |   59|  3.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3384|  10.4k|    } else {
 3385|  10.4k|      if (parsedCatchAll) {
  ------------------
  |  Branch (3385:11): [True: 194, False: 10.2k]
  ------------------
 3386|    194|        Error(token.loc, "multiple catch_all clauses not allowed");
 3387|    194|        return Result::Error;
 3388|    194|      }
 3389|  10.2k|      parsedCatchAll = true;
 3390|  10.2k|    }
 3391|       |
 3392|  13.8k|    CHECK_RESULT(ParseTerminatingInstrList(&catch_.exprs));
  ------------------
  |  |   55|  13.8k|  do {                              \
  |  |   56|  13.8k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.41k, False: 12.4k]
  |  |  ------------------
  |  |   57|  1.41k|      return ::wabt::Result::Error; \
  |  |   58|  1.41k|    }                               \
  |  |   59|  13.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3393|  12.4k|    EXPECT(Rpar);
  ------------------
  |  |   31|  12.4k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  12.4k|  do {                              \
  |  |  |  |   56|  12.4k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 577, False: 11.8k]
  |  |  |  |  ------------------
  |  |  |  |   57|    577|      return ::wabt::Result::Error; \
  |  |  |  |   58|    577|    }                               \
  |  |  |  |   59|  12.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3394|  11.8k|    catches->push_back(std::move(catch_));
 3395|  11.8k|  } while (Match(TokenType::Lpar) && IsCatch(Peek()));
  ------------------
  |  Branch (3395:12): [True: 1.97k, False: 9.88k]
  |  Branch (3395:38): [True: 1.45k, False: 522]
  ------------------
 3396|       |
 3397|  10.4k|  return Result::Ok;
 3398|  12.8k|}
_ZN4wabt10WastParser20ParseTryTableCatchesEPNSt3__16vectorINS_10TableCatchENS1_9allocatorIS3_EEEE:
 3400|  6.05k|Result WastParser::ParseTryTableCatches(TryTableVector* catches) {
 3401|  6.05k|  WABT_TRACE(ParseTryTableCatches);
 3402|       |
 3403|  9.42k|  while (IsTryTableCatch(PeekPair())) {
  ------------------
  |  Branch (3403:10): [True: 4.94k, False: 4.47k]
  ------------------
 3404|  4.94k|    Consume();
 3405|  4.94k|    TableCatch catch_(GetLocation());
 3406|  4.94k|    auto token = Consume();
 3407|  4.94k|    switch (token.token_type()) {
 3408|  3.90k|      case TokenType::Catch:
  ------------------
  |  Branch (3408:7): [True: 3.90k, False: 1.04k]
  ------------------
 3409|  3.90k|        catch_.kind = CatchKind::Catch;
 3410|  3.90k|        break;
 3411|    242|      case TokenType::CatchRef:
  ------------------
  |  Branch (3411:7): [True: 242, False: 4.70k]
  ------------------
 3412|    242|        catch_.kind = CatchKind::CatchRef;
 3413|    242|        break;
 3414|    606|      case TokenType::CatchAll:
  ------------------
  |  Branch (3414:7): [True: 606, False: 4.34k]
  ------------------
 3415|    606|        catch_.kind = CatchKind::CatchAll;
 3416|    606|        break;
 3417|    194|      case TokenType::CatchAllRef:
  ------------------
  |  Branch (3417:7): [True: 194, False: 4.75k]
  ------------------
 3418|    194|        catch_.kind = CatchKind::CatchAllRef;
 3419|    194|        break;
 3420|      0|      default:
  ------------------
  |  Branch (3420:7): [True: 0, False: 4.94k]
  ------------------
 3421|      0|        WABT_UNREACHABLE;
  ------------------
  |  |  112|      0|#define WABT_UNREACHABLE abort()
  ------------------
 3422|  4.94k|    }
 3423|  4.94k|    if (catch_.kind == CatchKind::Catch || catch_.kind == CatchKind::CatchRef) {
  ------------------
  |  Branch (3423:9): [True: 3.90k, False: 1.04k]
  |  Branch (3423:44): [True: 242, False: 800]
  ------------------
 3424|  4.14k|      CHECK_RESULT(ParseVar(&catch_.tag));
  ------------------
  |  |   55|  4.14k|  do {                              \
  |  |   56|  4.14k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 591, False: 3.55k]
  |  |  ------------------
  |  |   57|    591|      return ::wabt::Result::Error; \
  |  |   58|    591|    }                               \
  |  |   59|  4.14k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3425|  4.14k|    }
 3426|  4.35k|    CHECK_RESULT(ParseVar(&catch_.target));
  ------------------
  |  |   55|  4.35k|  do {                              \
  |  |   56|  4.35k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 573, False: 3.78k]
  |  |  ------------------
  |  |   57|    573|      return ::wabt::Result::Error; \
  |  |   58|    573|    }                               \
  |  |   59|  4.35k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3427|  3.78k|    EXPECT(Rpar);
  ------------------
  |  |   31|  3.78k|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|  3.78k|  do {                              \
  |  |  |  |   56|  3.78k|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 417, False: 3.36k]
  |  |  |  |  ------------------
  |  |  |  |   57|    417|      return ::wabt::Result::Error; \
  |  |  |  |   58|    417|    }                               \
  |  |  |  |   59|  3.78k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3428|  3.36k|    catches->push_back(std::move(catch_));
 3429|  3.36k|  }
 3430|       |
 3431|  4.47k|  return Result::Ok;
 3432|  6.05k|}
_ZN4wabt10WastParser15ParseGlobalTypeEPNS_6GlobalE:
 3434|   446k|Result WastParser::ParseGlobalType(Global* global) {
 3435|   446k|  WABT_TRACE(ParseGlobalType);
 3436|   446k|  if (MatchLpar(TokenType::Mut)) {
  ------------------
  |  Branch (3436:7): [True: 1.16k, False: 445k]
  ------------------
 3437|  1.16k|    global->mutable_ = true;
 3438|  1.16k|    Var type;
 3439|  1.16k|    CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|  1.16k|  do {                              \
  |  |   56|  1.16k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 232, False: 928]
  |  |  ------------------
  |  |   57|    232|      return ::wabt::Result::Error; \
  |  |   58|    232|    }                               \
  |  |   59|  1.16k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3440|    928|    global->type = Type(type.index());
 3441|    928|    CHECK_RESULT(ErrorIfLpar({"i32", "i64", "f32", "f64"}));
  ------------------
  |  |   55|    928|  do {                              \
  |  |   56|    928|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 222, False: 706]
  |  |  ------------------
  |  |   57|    222|      return ::wabt::Result::Error; \
  |  |   58|    222|    }                               \
  |  |   59|    928|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3442|    706|    EXPECT(Rpar);
  ------------------
  |  |   31|    706|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    706|  do {                              \
  |  |  |  |   56|    706|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 507, False: 199]
  |  |  |  |  ------------------
  |  |  |  |   57|    507|      return ::wabt::Result::Error; \
  |  |  |  |   58|    507|    }                               \
  |  |  |  |   59|    706|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3443|   445k|  } else {
 3444|   445k|    Var type;
 3445|   445k|    CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|   445k|  do {                              \
  |  |   56|   445k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 43.0k, False: 402k]
  |  |  ------------------
  |  |   57|  43.0k|      return ::wabt::Result::Error; \
  |  |   58|  43.0k|    }                               \
  |  |   59|   445k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3446|   402k|    global->type = Type(type.index());
 3447|   402k|  }
 3448|       |
 3449|   402k|  return Result::Ok;
 3450|   446k|}
_ZN4wabt10WastParser18ParseModuleCommandEPNS_6ScriptEPNSt3__110unique_ptrINS_7CommandENS3_14default_deleteIS5_EEEE:
 3581|     80|Result WastParser::ParseModuleCommand(Script* script, CommandPtr* out_command) {
 3582|     80|  WABT_TRACE(ParseModuleCommand);
 3583|     80|  std::unique_ptr<ScriptModule> script_module;
 3584|     80|  CHECK_RESULT(ParseScriptModule(&script_module));
  ------------------
  |  |   55|     80|  do {                              \
  |  |   56|     80|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 26, False: 54]
  |  |  ------------------
  |  |   57|     26|      return ::wabt::Result::Error; \
  |  |   58|     26|    }                               \
  |  |   59|     80|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3585|       |
 3586|     54|  Module* module = nullptr;
 3587|       |
 3588|     54|  switch (script_module->type()) {
  ------------------
  |  Branch (3588:11): [True: 0, False: 54]
  ------------------
 3589|     54|    case ScriptModuleType::Text: {
  ------------------
  |  Branch (3589:5): [True: 54, False: 0]
  ------------------
 3590|     54|      auto command = std::make_unique<ModuleCommand>();
 3591|     54|      module = &command->module;
 3592|     54|      *module = std::move(cast<TextScriptModule>(script_module.get())->module);
 3593|     54|      *out_command = std::move(command);
 3594|     54|      break;
 3595|      0|    }
 3596|       |
 3597|      0|    case ScriptModuleType::Binary: {
  ------------------
  |  Branch (3597:5): [True: 0, False: 54]
  ------------------
 3598|      0|      auto command = std::make_unique<ScriptModuleCommand>();
 3599|      0|      module = &command->module;
 3600|      0|      auto* bsm = cast<BinaryScriptModule>(script_module.get());
 3601|      0|      ReadBinaryOptions options;
 3602|       |#if WABT_TRACING
 3603|       |      auto log_stream = FileStream::CreateStdout();
 3604|       |      options.log_stream = log_stream.get();
 3605|       |#endif
 3606|      0|      options.features = options_->features;
 3607|      0|      Errors errors;
 3608|      0|      const char* filename = "<text>";
 3609|      0|      if (options_->parse_binary_modules) {
  ------------------
  |  Branch (3609:11): [True: 0, False: 0]
  ------------------
 3610|      0|        ReadBinaryIr(filename, bsm->data.data(), bsm->data.size(), options,
 3611|      0|                     &errors, module);
 3612|      0|      }
 3613|      0|      module->name = bsm->name;
 3614|      0|      module->loc = bsm->loc;
 3615|      0|      for (const auto& error : errors) {
  ------------------
  |  Branch (3615:30): [True: 0, False: 0]
  ------------------
 3616|      0|        if (error.loc.offset == kInvalidOffset) {
  ------------------
  |  Branch (3616:13): [True: 0, False: 0]
  ------------------
 3617|      0|          Error(bsm->loc, "error in binary module: %s", error.message.c_str());
 3618|      0|        } else {
 3619|      0|          Error(bsm->loc, "error in binary module: @0x%08" PRIzx ": %s",
 3620|      0|                error.loc.offset, error.message.c_str());
 3621|      0|        }
 3622|      0|      }
 3623|       |
 3624|      0|      command->script_module = std::move(script_module);
 3625|      0|      *out_command = std::move(command);
 3626|      0|      break;
 3627|      0|    }
 3628|       |
 3629|      0|    case ScriptModuleType::Quoted:
  ------------------
  |  Branch (3629:5): [True: 0, False: 54]
  ------------------
 3630|      0|      auto command = std::make_unique<ModuleCommand>();
 3631|      0|      module = &command->module;
 3632|      0|      auto* qsm = cast<QuotedScriptModule>(script_module.get());
 3633|      0|      Errors errors;
 3634|      0|      const char* filename = "<text>";
 3635|      0|      std::unique_ptr<Module> m;
 3636|      0|      std::unique_ptr<WastLexer> lexer = WastLexer::CreateBufferLexer(
 3637|      0|          filename, qsm->data.data(), qsm->data.size(), &errors);
 3638|      0|      auto result = ParseWatModule(lexer.get(), &m, &errors, options_);
 3639|      0|      for (const auto& error : errors) {
  ------------------
  |  Branch (3639:30): [True: 0, False: 0]
  ------------------
 3640|      0|        if (error.loc.offset == kInvalidOffset) {
  ------------------
  |  Branch (3640:13): [True: 0, False: 0]
  ------------------
 3641|      0|          Error(qsm->loc, "error in quoted module: %s", error.message.c_str());
 3642|      0|        } else {
 3643|      0|          Error(qsm->loc, "error in quoted module: @0x%08" PRIzx ": %s",
 3644|      0|                error.loc.offset, error.message.c_str());
 3645|      0|        }
 3646|      0|      }
 3647|      0|      if (Succeeded(result)) {
  ------------------
  |  Branch (3647:11): [True: 0, False: 0]
  ------------------
 3648|      0|        *module = std::move(*m.get());
 3649|      0|      }
 3650|      0|      *out_command = std::move(command);
 3651|      0|      break;
 3652|     54|  }
 3653|       |
 3654|       |  // script is nullptr when ParseModuleCommand is called from ParseModule.
 3655|     54|  if (script) {
  ------------------
  |  Branch (3655:7): [True: 0, False: 54]
  ------------------
 3656|      0|    Index command_index = script->commands.size();
 3657|       |
 3658|      0|    if (!module->name.empty()) {
  ------------------
  |  Branch (3658:9): [True: 0, False: 0]
  ------------------
 3659|      0|      script->module_bindings.emplace(module->name,
 3660|      0|                                      Binding(module->loc, command_index));
 3661|      0|    }
 3662|       |
 3663|      0|    last_module_index_ = command_index;
 3664|      0|  }
 3665|       |
 3666|     54|  return Result::Ok;
 3667|     54|}
_ZN4wabt10WastParser17ParseScriptModuleEPNSt3__110unique_ptrINS_12ScriptModuleENS1_14default_deleteIS3_EEEE:
 3773|     80|    std::unique_ptr<ScriptModule>* out_module) {
 3774|     80|  WABT_TRACE(ParseScriptModule);
 3775|     80|  EXPECT(Lpar);
  ------------------
  |  |   31|     80|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|     80|  do {                              \
  |  |  |  |   56|     80|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 80]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|     80|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3776|     80|  Location loc = GetLocation();
 3777|     80|  EXPECT(Module);
  ------------------
  |  |   31|     80|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|     80|  do {                              \
  |  |  |  |   56|     80|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 0, False: 80]
  |  |  |  |  ------------------
  |  |  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |  |  |   58|      0|    }                               \
  |  |  |  |   59|     80|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3778|     80|  std::string name;
 3779|     80|  ParseBindVarOpt(&name);
 3780|       |
 3781|     80|  switch (Peek()) {
 3782|      0|    case TokenType::Bin: {
  ------------------
  |  Branch (3782:5): [True: 0, False: 80]
  ------------------
 3783|      0|      Consume();
 3784|      0|      std::vector<uint8_t> data;
 3785|       |      // TODO(binji): The spec allows this to be empty, switch to
 3786|       |      // ParseTextListOpt.
 3787|      0|      CHECK_RESULT(ParseTextList(&data));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3788|       |
 3789|      0|      auto bsm = std::make_unique<BinaryScriptModule>();
 3790|      0|      bsm->name = name;
 3791|      0|      bsm->loc = loc;
 3792|      0|      bsm->data = std::move(data);
 3793|      0|      *out_module = std::move(bsm);
 3794|      0|      break;
 3795|      0|    }
 3796|       |
 3797|      0|    case TokenType::Quote: {
  ------------------
  |  Branch (3797:5): [True: 0, False: 80]
  ------------------
 3798|      0|      Consume();
 3799|      0|      std::vector<uint8_t> data;
 3800|       |      // TODO(binji): The spec allows this to be empty, switch to
 3801|       |      // ParseTextListOpt.
 3802|      0|      CHECK_RESULT(ParseTextList(&data));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3803|       |
 3804|      0|      auto qsm = std::make_unique<QuotedScriptModule>();
 3805|      0|      qsm->name = name;
 3806|      0|      qsm->loc = loc;
 3807|      0|      qsm->data = std::move(data);
 3808|      0|      *out_module = std::move(qsm);
 3809|      0|      break;
 3810|      0|    }
 3811|       |
 3812|     80|    default: {
  ------------------
  |  Branch (3812:5): [True: 80, False: 0]
  ------------------
 3813|     80|      auto tsm = std::make_unique<TextScriptModule>();
 3814|     80|      tsm->module.name = name;
 3815|     80|      tsm->module.loc = loc;
 3816|     80|      if (IsModuleField(PeekPair()) || PeekIsCustom()) {
  ------------------
  |  Branch (3816:11): [True: 68, False: 12]
  |  Branch (3816:40): [True: 0, False: 12]
  ------------------
 3817|     68|        CHECK_RESULT(ParseModuleFieldList(&tsm->module));
  ------------------
  |  |   55|     68|  do {                              \
  |  |   56|     68|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 13, False: 55]
  |  |  ------------------
  |  |   57|     13|      return ::wabt::Result::Error; \
  |  |   58|     13|    }                               \
  |  |   59|     68|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3818|     68|      } else if (!PeekMatch(TokenType::Rpar)) {
  ------------------
  |  Branch (3818:18): [True: 11, False: 1]
  ------------------
 3819|     11|        ConsumeIfLpar();
 3820|     11|        return ErrorExpected({"a module field"});
 3821|     11|      }
 3822|     56|      *out_module = std::move(tsm);
 3823|     56|      break;
 3824|     80|    }
 3825|     80|  }
 3826|       |
 3827|     56|  EXPECT(Rpar);
  ------------------
  |  |   31|     56|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|     56|  do {                              \
  |  |  |  |   56|     56|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 2, False: 54]
  |  |  |  |  ------------------
  |  |  |  |   57|      2|      return ::wabt::Result::Error; \
  |  |  |  |   58|      2|    }                               \
  |  |  |  |   59|     56|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3828|     54|  return Result::Ok;
 3829|     56|}
_ZN4wabt10WastParser19CheckImportOrderingEPNS_6ModuleE:
 3872|   369k|void WastParser::CheckImportOrdering(Module* module) {
 3873|   369k|  if (module->funcs.size() != module->num_func_imports ||
  ------------------
  |  Branch (3873:7): [True: 224k, False: 144k]
  ------------------
 3874|   369k|      module->tables.size() != module->num_table_imports ||
  ------------------
  |  Branch (3874:7): [True: 1.53k, False: 143k]
  ------------------
 3875|   369k|      module->memories.size() != module->num_memory_imports ||
  ------------------
  |  Branch (3875:7): [True: 3.87k, False: 139k]
  ------------------
 3876|   369k|      module->globals.size() != module->num_global_imports ||
  ------------------
  |  Branch (3876:7): [True: 28.7k, False: 110k]
  ------------------
 3877|   369k|      module->tags.size() != module->num_tag_imports) {
  ------------------
  |  Branch (3877:7): [True: 0, False: 110k]
  ------------------
 3878|   258k|    Error(GetLocation(),
 3879|   258k|          "imports must occur before all non-import definitions");
 3880|   258k|  }
 3881|   369k|}
_ZNK4wabt10WastParser8HasErrorEv:
 3883|  3.46k|bool WastParser::HasError() const {
 3884|  3.46k|  return std::any_of(errors_->begin(), errors_->end(), [](const auto& x) {
 3885|  3.46k|    return x.error_level == ErrorLevel::Error;
 3886|  3.46k|  });
 3887|  3.46k|}
_ZN4wabt10WastParser10TokenQueue9push_backENS_5TokenE:
 3889|  25.5M|void WastParser::TokenQueue::push_back(Token t) {
 3890|  25.5M|  assert(!tokens[!i]);
 3891|  25.5M|  tokens[!i] = t;
 3892|  25.5M|  if (empty()) {
  ------------------
  |  Branch (3892:7): [True: 10.9M, False: 14.6M]
  ------------------
 3893|  10.9M|    i = !i;
 3894|  10.9M|  }
 3895|  25.5M|}
_ZN4wabt10WastParser10TokenQueue9pop_frontEv:
 3897|  25.5M|void WastParser::TokenQueue::pop_front() {
 3898|  25.5M|  assert(tokens[i]);
 3899|  25.5M|  tokens[i].reset();
 3900|  25.5M|  i = !i;
 3901|  25.5M|}
_ZNK4wabt10WastParser10TokenQueue2atEm:
 3903|   126M|const Token& WastParser::TokenQueue::at(size_t n) const {
 3904|   126M|  assert(n <= 1);
 3905|   126M|  return tokens[i ^ static_cast<bool>(n)].value();
 3906|   126M|}
_ZNK4wabt10WastParser10TokenQueue5frontEv:
 3908|  34.8M|const Token& WastParser::TokenQueue::front() const {
 3909|  34.8M|  return at(0);
 3910|  34.8M|}
_ZNK4wabt10WastParser10TokenQueue5emptyEv:
 3912|   176M|bool WastParser::TokenQueue::empty() const {
 3913|   176M|  return !tokens[i];
 3914|   176M|}
_ZNK4wabt10WastParser10TokenQueue4sizeEv:
 3916|   116M|size_t WastParser::TokenQueue::size() const {
 3917|   116M|  return empty() ? 0 : 1 + tokens[!i].has_value();
  ------------------
  |  Branch (3917:10): [True: 9.93M, False: 106M]
  ------------------
 3918|   116M|}
_ZN4wabt14ParseWatModuleEPNS_9WastLexerEPNSt3__110unique_ptrINS_6ModuleENS2_14default_deleteIS4_EEEEPNS2_6vectorINS_5ErrorENS2_9allocatorISA_EEEEPNS_16WastParseOptionsE:
 3923|  23.2k|                      WastParseOptions* options) {
 3924|  23.2k|  assert(out_module != nullptr);
 3925|  23.2k|  assert(options != nullptr);
 3926|  23.2k|  WastParser parser(lexer, errors, options);
 3927|  23.2k|  CHECK_RESULT(parser.ParseModule(out_module));
  ------------------
  |  |   55|  23.2k|  do {                              \
  |  |   56|  23.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 21.5k, False: 1.61k]
  |  |  ------------------
  |  |   57|  21.5k|      return ::wabt::Result::Error; \
  |  |   58|  21.5k|    }                               \
  |  |   59|  23.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3928|  1.61k|  return Result::Ok;
 3929|  23.2k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_16IsExprENSt3__15arrayINS_9TokenTypeELm2EEE:
  234|  7.56M|bool IsExpr(TokenTypePair pair) {
  235|  7.56M|  return pair[0] == TokenType::Lpar && IsPlainOrBlockInstr(pair[1]);
  ------------------
  |  Branch (235:10): [True: 2.09M, False: 5.47M]
  |  Branch (235:40): [True: 1.26M, False: 831k]
  ------------------
  236|  7.56M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_119IsPlainOrBlockInstrENS_9TokenTypeE:
  230|  7.29M|bool IsPlainOrBlockInstr(TokenType token_type) {
  231|  7.29M|  return IsPlainInstr(token_type) || IsBlockInstr(token_type);
  ------------------
  |  Branch (231:10): [True: 1.22M, False: 6.07M]
  |  Branch (231:38): [True: 496k, False: 5.57M]
  ------------------
  232|  7.29M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_117IsIndexLikelyTypeEj:
  545|  77.1k|bool IsIndexLikelyType(Index index) {
  546|       |  // TODO: Incorrect values can be misinterpreted by the parser.
  547|  77.1k|  return index >= static_cast<Index>(Type::Void);
  548|  77.1k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_112IsPowerOfTwoEj:
   39|    819|bool IsPowerOfTwo(uint32_t x) {
   40|    819|  return x && ((x & (x - 1)) == 0);
  ------------------
  |  Branch (40:10): [True: 360, False: 459]
  |  Branch (40:15): [True: 207, False: 153]
  ------------------
   41|    819|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_113IsModuleFieldENSt3__15arrayINS_9TokenTypeELm2EEE:
  256|  9.14M|bool IsModuleField(TokenTypePair pair) {
  257|  9.14M|  if (pair[0] != TokenType::Lpar) {
  ------------------
  |  Branch (257:7): [True: 1.97M, False: 7.16M]
  ------------------
  258|  1.97M|    return false;
  259|  1.97M|  }
  260|       |
  261|  7.16M|  switch (pair[1]) {
  262|   134k|    case TokenType::Data:
  ------------------
  |  Branch (262:5): [True: 134k, False: 7.02M]
  ------------------
  263|   422k|    case TokenType::Elem:
  ------------------
  |  Branch (263:5): [True: 287k, False: 6.87M]
  ------------------
  264|   523k|    case TokenType::Tag:
  ------------------
  |  Branch (264:5): [True: 101k, False: 7.06M]
  ------------------
  265|   544k|    case TokenType::Export:
  ------------------
  |  Branch (265:5): [True: 21.1k, False: 7.14M]
  ------------------
  266|  3.80M|    case TokenType::Func:
  ------------------
  |  Branch (266:5): [True: 3.26M, False: 3.89M]
  ------------------
  267|  3.95M|    case TokenType::Type:
  ------------------
  |  Branch (267:5): [True: 148k, False: 7.01M]
  ------------------
  268|  4.93M|    case TokenType::Global:
  ------------------
  |  Branch (268:5): [True: 972k, False: 6.18M]
  ------------------
  269|  5.17M|    case TokenType::Import:
  ------------------
  |  Branch (269:5): [True: 246k, False: 6.91M]
  ------------------
  270|  6.28M|    case TokenType::Memory:
  ------------------
  |  Branch (270:5): [True: 1.10M, False: 6.05M]
  ------------------
  271|  6.28M|    case TokenType::Start:
  ------------------
  |  Branch (271:5): [True: 2.11k, False: 7.15M]
  ------------------
  272|  6.62M|    case TokenType::Table:
  ------------------
  |  Branch (272:5): [True: 339k, False: 6.82M]
  ------------------
  273|  6.62M|      return true;
  274|   539k|    default:
  ------------------
  |  Branch (274:5): [True: 539k, False: 6.62M]
  ------------------
  275|   539k|      return false;
  276|  7.16M|  }
  277|  7.16M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_19IsLparAnnENSt3__15arrayINS_9TokenTypeELm2EEE:
  242|  2.26M|bool IsLparAnn(TokenTypePair pair) {
  243|  2.26M|  return pair[0] == TokenType::LparAnn;
  244|  2.26M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_116ResolveFuncTypesEPNS_6ModuleEPNSt3__16vectorINS_5ErrorENS3_9allocatorIS5_EEEE:
  476|  6.93k|Result ResolveFuncTypes(Module* module, Errors* errors) {
  477|  6.93k|  Result result = Result::Ok;
  478|  1.70M|  for (ModuleField& field : module->fields) {
  ------------------
  |  Branch (478:27): [True: 1.70M, False: 6.93k]
  ------------------
  479|  1.70M|    Func* func = nullptr;
  480|  1.70M|    FuncDeclaration* decl = nullptr;
  481|  1.70M|    if (auto* func_field = dyn_cast<FuncModuleField>(&field)) {
  ------------------
  |  Branch (481:15): [True: 987k, False: 717k]
  ------------------
  482|   987k|      func = &func_field->func;
  483|   987k|      decl = &func->decl;
  484|   987k|    } else if (auto* tag_field = dyn_cast<TagModuleField>(&field)) {
  ------------------
  |  Branch (484:22): [True: 0, False: 717k]
  ------------------
  485|      0|      decl = &tag_field->tag.decl;
  486|   717k|    } else if (auto* import_field = dyn_cast<ImportModuleField>(&field)) {
  ------------------
  |  Branch (486:22): [True: 68.7k, False: 648k]
  ------------------
  487|  68.7k|      if (auto* func_import =
  ------------------
  |  Branch (487:17): [True: 6.14k, False: 62.5k]
  ------------------
  488|  68.7k|              dyn_cast<FuncImport>(import_field->import.get())) {
  489|       |        // Only check the declaration, not the function itself, since it is an
  490|       |        // import.
  491|  6.14k|        decl = &func_import->func.decl;
  492|  62.5k|      } else if (auto* tag_import =
  ------------------
  |  Branch (492:24): [True: 61.8k, False: 766]
  ------------------
  493|  62.5k|                     dyn_cast<TagImport>(import_field->import.get())) {
  494|  61.8k|        decl = &tag_import->tag.decl;
  495|  61.8k|      } else {
  496|    766|        continue;
  497|    766|      }
  498|   648k|    } else {
  499|   648k|      continue;
  500|   648k|    }
  501|       |
  502|  1.05M|    bool has_func_type_and_empty_signature = false;
  503|       |
  504|  1.05M|    if (decl) {
  ------------------
  |  Branch (504:9): [True: 1.05M, False: 0]
  ------------------
  505|  1.05M|      has_func_type_and_empty_signature =
  506|  1.05M|          ResolveFuncTypeWithEmptySignature(*module, decl);
  507|  1.05M|      ResolveImplicitlyDefinedFunctionType(field.loc, module, *decl);
  508|  1.05M|      result |=
  509|  1.05M|          CheckFuncTypeVarMatchesExplicit(field.loc, *module, *decl, errors);
  510|  1.05M|    }
  511|       |
  512|  1.05M|    if (func) {
  ------------------
  |  Branch (512:9): [True: 987k, False: 67.9k]
  ------------------
  513|   987k|      if (has_func_type_and_empty_signature) {
  ------------------
  |  Branch (513:11): [True: 1.04k, False: 986k]
  ------------------
  514|       |        // The call to ResolveFuncTypeWithEmptySignature may have updated the
  515|       |        // function signature so there are parameters. Since parameters and
  516|       |        // local variables share the same index space, we need to increment the
  517|       |        // local indexes bound to a given name by the number of parameters in
  518|       |        // the function.
  519|  1.04k|        for (auto& [name, binding] : func->bindings) {
  ------------------
  |  Branch (519:36): [True: 598, False: 1.04k]
  ------------------
  520|    598|          binding.index += func->GetNumParams();
  521|    598|        }
  522|  1.04k|      }
  523|       |
  524|   987k|      ResolveFuncTypesExprVisitorDelegate delegate(module, errors);
  525|   987k|      ExprVisitor visitor(&delegate);
  526|   987k|      result |= visitor.VisitFunc(func);
  527|   987k|    }
  528|  1.05M|  }
  529|  6.93k|  return result;
  530|  6.93k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_133ResolveFuncTypeWithEmptySignatureERKNS_6ModuleEPNS_15FuncDeclarationE:
  309|  1.10M|                                       FuncDeclaration* decl) {
  310|       |  // Resolve func type variables where the signature was not specified
  311|       |  // explicitly, e.g.: (func (type 1) ...)
  312|  1.10M|  if (decl->has_func_type && IsEmptySignature(decl->sig)) {
  ------------------
  |  Branch (312:7): [True: 20.1k, False: 1.08M]
  |  Branch (312:30): [True: 8.63k, False: 11.4k]
  ------------------
  313|  8.63k|    const FuncType* func_type = module.GetFuncType(decl->type_var);
  314|  8.63k|    if (func_type) {
  ------------------
  |  Branch (314:9): [True: 4.19k, False: 4.44k]
  ------------------
  315|  4.19k|      decl->sig = func_type->sig;
  316|  4.19k|      return true;
  317|  4.19k|    }
  318|  8.63k|  }
  319|  1.09M|  return false;
  320|  1.10M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_116IsEmptySignatureERKNS_13FuncSignatureE:
  304|  20.1k|bool IsEmptySignature(const FuncSignature& sig) {
  305|  20.1k|  return sig.result_types.empty() && sig.param_types.empty();
  ------------------
  |  Branch (305:10): [True: 18.9k, False: 1.16k]
  |  Branch (305:38): [True: 8.63k, False: 10.3k]
  ------------------
  306|  20.1k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_136ResolveImplicitlyDefinedFunctionTypeERKNS_8LocationEPNS_6ModuleERKNS_15FuncDeclarationE:
  324|  1.06M|                                          const FuncDeclaration& decl) {
  325|       |  // Resolve implicitly defined function types, e.g.: (func (param i32) ...)
  326|  1.06M|  if (!decl.has_func_type) {
  ------------------
  |  Branch (326:7): [True: 1.04M, False: 17.3k]
  ------------------
  327|  1.04M|    Index func_type_index = module->GetFuncTypeIndex(decl.sig);
  328|  1.04M|    if (func_type_index == kInvalidIndex) {
  ------------------
  |  Branch (328:9): [True: 5.59k, False: 1.03M]
  ------------------
  329|  5.59k|      auto func_type_field = std::make_unique<TypeModuleField>(loc);
  330|  5.59k|      auto func_type = std::make_unique<FuncType>();
  331|  5.59k|      func_type->sig = decl.sig;
  332|  5.59k|      func_type_field->type = std::move(func_type);
  333|  5.59k|      module->AppendField(std::move(func_type_field));
  334|  5.59k|    }
  335|  1.04M|  }
  336|  1.06M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_131CheckFuncTypeVarMatchesExplicitERKNS_8LocationERKNS_6ModuleERKNS_15FuncDeclarationEPNSt3__16vectorINS_5ErrorENSA_9allocatorISC_EEEE:
  383|  1.10M|                                       Errors* errors) {
  384|  1.10M|  Result result = Result::Ok;
  385|  1.10M|  if (decl.has_func_type) {
  ------------------
  |  Branch (385:7): [True: 20.1k, False: 1.08M]
  ------------------
  386|  20.1k|    const FuncType* func_type = module.GetFuncType(decl.type_var);
  387|  20.1k|    if (func_type) {
  ------------------
  |  Branch (387:9): [True: 13.5k, False: 6.58k]
  ------------------
  388|  13.5k|      result |=
  389|  13.5k|          CheckTypes(loc, decl.sig.result_types, func_type->sig.result_types,
  390|  13.5k|                     "function", "result", errors);
  391|  13.5k|      result |=
  392|  13.5k|          CheckTypes(loc, decl.sig.param_types, func_type->sig.param_types,
  393|  13.5k|                     "function", "argument", errors);
  394|  13.5k|    } else if (!(decl.sig.param_types.empty() &&
  ------------------
  |  Branch (394:18): [True: 5.12k, False: 1.46k]
  ------------------
  395|  6.58k|                 decl.sig.result_types.empty())) {
  ------------------
  |  Branch (395:18): [True: 4.44k, False: 687]
  ------------------
  396|       |      // We want to check whether the function type at the explicit index
  397|       |      // matches the given param and result types. If they were omitted then
  398|       |      // they'll be resolved automatically (see
  399|       |      // ResolveFuncTypeWithEmptySignature), but if they are provided then we
  400|       |      // have to check. If we get here then the type var is invalid, so we
  401|       |      // can't check whether they match.
  402|  2.14k|      if (decl.type_var.is_index()) {
  ------------------
  |  Branch (402:11): [True: 1.13k, False: 1.00k]
  ------------------
  403|  1.13k|        errors->emplace_back(ErrorLevel::Error, loc,
  404|  1.13k|                             StringPrintf("invalid func type index %" PRIindex,
  ------------------
  |  |   84|  1.13k|#define PRIindex "u"
  ------------------
  405|  1.13k|                                          decl.type_var.index()));
  406|  1.13k|      } else {
  407|  1.00k|        errors->emplace_back(ErrorLevel::Error, loc,
  408|  1.00k|                             StringPrintf("expected func type identifier %s",
  409|  1.00k|                                          decl.type_var.name().c_str()));
  410|  1.00k|      }
  411|  2.14k|      result = Result::Error;
  412|  2.14k|    }
  413|  20.1k|  }
  414|  1.10M|  return result;
  415|  1.10M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_110CheckTypesERKNS_8LocationERKNSt3__16vectorINS_4TypeENS4_9allocatorIS6_EEEESB_PKcSD_PNS5_INS_5ErrorENS7_ISE_EEEE:
  363|  27.0k|                  Errors* errors) {
  364|  27.0k|  Result result = Result::Ok;
  365|  27.0k|  if (actual.size() == expected.size()) {
  ------------------
  |  Branch (365:7): [True: 24.2k, False: 2.79k]
  ------------------
  366|  41.3k|    for (size_t i = 0; i < actual.size(); ++i) {
  ------------------
  |  Branch (366:24): [True: 17.1k, False: 24.2k]
  ------------------
  367|  17.1k|      result |= CheckTypeIndex(loc, actual[i], expected[i], desc, i, index_kind,
  368|  17.1k|                               errors);
  369|  17.1k|    }
  370|  24.2k|  } else {
  371|  2.79k|    errors->emplace_back(
  372|  2.79k|        ErrorLevel::Error, loc,
  373|  2.79k|        StringPrintf("expected %" PRIzd " %ss, got %" PRIzd, expected.size(),
  ------------------
  |  |  265|  2.79k|#define PRIzd "zd"
  ------------------
  374|  2.79k|                     index_kind, actual.size()));
  375|  2.79k|    result = Result::Error;
  376|  2.79k|  }
  377|  27.0k|  return result;
  378|  27.0k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_114CheckTypeIndexERKNS_8LocationENS_4TypeES4_PKcjS6_PNSt3__16vectorINS_5ErrorENS7_9allocatorIS9_EEEE:
  344|  17.1k|                      Errors* errors) {
  345|       |  // Types must match exactly; no subtyping should be allowed.
  346|  17.1k|  if (actual != expected) {
  ------------------
  |  Branch (346:7): [True: 15.3k, False: 1.79k]
  ------------------
  347|  15.3k|    errors->emplace_back(
  348|  15.3k|        ErrorLevel::Error, loc,
  349|  15.3k|        StringPrintf("type mismatch for %s %" PRIindex
  350|  15.3k|                     " of %s. got %s, expected %s",
  351|  15.3k|                     index_kind, index, desc, actual.GetName().c_str(),
  352|  15.3k|                     expected.GetName().c_str()));
  353|  15.3k|    return Result::Error;
  354|  15.3k|  }
  355|  1.79k|  return Result::Ok;
  356|  17.1k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegateC2EPNS_6ModuleEPNSt3__16vectorINS_5ErrorENS4_9allocatorIS6_EEEE:
  424|   987k|      : module_(module), errors_(errors) {}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate14BeginBlockExprEPNS_13BlockExprBaseILNS_8ExprTypeE8EEE:
  433|  4.00k|  Result BeginBlockExpr(BlockExpr* expr) override {
  434|  4.00k|    ResolveBlockDeclaration(expr->loc, &expr->block.decl);
  435|  4.00k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_,
  436|  4.00k|                                           expr->block.decl, errors_);
  437|  4.00k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate23ResolveBlockDeclarationERKNS_8LocationEPNS_15FuncDeclarationE:
  426|  43.4k|  void ResolveBlockDeclaration(const Location& loc, BlockDeclaration* decl) {
  427|  43.4k|    ResolveFuncTypeWithEmptySignature(*module_, decl);
  428|  43.4k|    if (!IsInlinableFuncSignature(decl->sig)) {
  ------------------
  |  Branch (428:9): [True: 1.00k, False: 42.4k]
  ------------------
  429|  1.00k|      ResolveImplicitlyDefinedFunctionType(loc, module_, *decl);
  430|  1.00k|    }
  431|  43.4k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_124IsInlinableFuncSignatureERKNS_13FuncSignatureE:
  417|  43.4k|bool IsInlinableFuncSignature(const FuncSignature& sig) {
  418|  43.4k|  return sig.GetNumParams() == 0 && sig.GetNumResults() <= 1;
  ------------------
  |  Branch (418:10): [True: 42.4k, False: 987]
  |  Branch (418:37): [True: 42.4k, False: 14]
  ------------------
  419|  43.4k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate18OnCallIndirectExprEPNS_16CallIndirectExprE:
  457|  2.35k|  Result OnCallIndirectExpr(CallIndirectExpr* expr) override {
  458|  2.35k|    ResolveFuncTypeWithEmptySignature(*module_, &expr->decl);
  459|  2.35k|    ResolveImplicitlyDefinedFunctionType(expr->loc, module_, expr->decl);
  460|  2.35k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_, expr->decl,
  461|  2.35k|                                           errors_);
  462|  2.35k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate11BeginIfExprEPNS_6IfExprE:
  439|  2.22k|  Result BeginIfExpr(IfExpr* expr) override {
  440|  2.22k|    ResolveBlockDeclaration(expr->loc, &expr->true_.decl);
  441|  2.22k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_,
  442|  2.22k|                                           expr->true_.decl, errors_);
  443|  2.22k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate13BeginLoopExprEPNS_13BlockExprBaseILNS_8ExprTypeE27EEE:
  445|  8.87k|  Result BeginLoopExpr(LoopExpr* expr) override {
  446|  8.87k|    ResolveBlockDeclaration(expr->loc, &expr->block.decl);
  447|  8.87k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_,
  448|  8.87k|                                           expr->block.decl, errors_);
  449|  8.87k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate24OnReturnCallIndirectExprEPNS_22ReturnCallIndirectExprE:
  464|  2.35k|  Result OnReturnCallIndirectExpr(ReturnCallIndirectExpr* expr) override {
  465|  2.35k|    ResolveFuncTypeWithEmptySignature(*module_, &expr->decl);
  466|  2.35k|    ResolveImplicitlyDefinedFunctionType(expr->loc, module_, expr->decl);
  467|  2.35k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_, expr->decl,
  468|  2.35k|                                           errors_);
  469|  2.35k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_135ResolveFuncTypesExprVisitorDelegate12BeginTryExprEPNS_7TryExprE:
  451|  28.2k|  Result BeginTryExpr(TryExpr* expr) override {
  452|  28.2k|    ResolveBlockDeclaration(expr->loc, &expr->block.decl);
  453|  28.2k|    return CheckFuncTypeVarMatchesExplicit(expr->loc, *module_,
  454|  28.2k|                                           expr->block.decl, errors_);
  455|  28.2k|  }
wast-parser.cc:_ZN4wabt12_GLOBAL__N_124AppendInlineExportFieldsEPNS_6ModuleEPNS_14intrusive_listINS_11ModuleFieldEEEj:
  534|  2.74M|                              Index index) {
  535|  2.74M|  Location last_field_loc = module->fields.back().loc;
  536|       |
  537|  2.74M|  for (ModuleField& field : *fields) {
  ------------------
  |  Branch (537:27): [True: 42.4k, False: 2.74M]
  ------------------
  538|  42.4k|    auto* export_field = cast<ExportModuleField>(&field);
  539|  42.4k|    export_field->export_.var = Var(index, last_field_loc);
  540|  42.4k|  }
  541|       |
  542|  2.74M|  module->AppendFields(fields);
  543|  2.74M|}
wast-parser.cc:_ZZN4wabt10WastParser10ParseFieldEPNS_5FieldEENK3$_0clEv:
 1656|  3.13k|  auto parse_mut_valuetype = [&]() -> Result {
 1657|       |    // TODO: Share with ParseGlobalType?
 1658|  3.13k|    if (MatchLpar(TokenType::Mut)) {
  ------------------
  |  Branch (1658:9): [True: 620, False: 2.51k]
  ------------------
 1659|    620|      field->mutable_ = true;
 1660|    620|      Var type;
 1661|    620|      CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|    620|  do {                              \
  |  |   56|    620|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 216, False: 404]
  |  |  ------------------
  |  |   57|    216|      return ::wabt::Result::Error; \
  |  |   58|    216|    }                               \
  |  |   59|    620|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1662|    404|      field->type = Type(type.index());
 1663|    404|      EXPECT(Rpar);
  ------------------
  |  |   31|    404|#define EXPECT(token_type) CHECK_RESULT(Expect(TokenType::token_type))
  |  |  ------------------
  |  |  |  |   55|    404|  do {                              \
  |  |  |  |   56|    404|    if (Failed(expr)) {             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (56:9): [True: 210, False: 194]
  |  |  |  |  ------------------
  |  |  |  |   57|    210|      return ::wabt::Result::Error; \
  |  |  |  |   58|    210|    }                               \
  |  |  |  |   59|    404|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1664|  2.51k|    } else {
 1665|  2.51k|      field->mutable_ = false;
 1666|  2.51k|      Var type;
 1667|  2.51k|      CHECK_RESULT(ParseValueType(&type));
  ------------------
  |  |   55|  2.51k|  do {                              \
  |  |   56|  2.51k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.64k, False: 869]
  |  |  ------------------
  |  |   57|  1.64k|      return ::wabt::Result::Error; \
  |  |   58|  1.64k|    }                               \
  |  |   59|  2.51k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1668|    869|      field->type = Type(type.index());
 1669|    869|    }
 1670|  1.06k|    return Result::Ok;
 1671|  3.13k|  };
wast-parser.cc:_ZN4wabt12_GLOBAL__N_17IsInstrENSt3__15arrayINS_9TokenTypeELm2EEE:
  238|  5.19M|bool IsInstr(TokenTypePair pair) {
  239|  5.19M|  return IsPlainOrBlockInstr(pair[0]) || IsExpr(pair);
  ------------------
  |  Branch (239:10): [True: 452k, False: 4.74M]
  |  Branch (239:42): [True: 408k, False: 4.33M]
  ------------------
  240|  5.19M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_112IsPlainInstrENS_9TokenTypeE:
  152|  8.60M|bool IsPlainInstr(TokenType token_type) {
  153|  8.60M|  switch (token_type) {
  154|  1.03k|    case TokenType::Unreachable:
  ------------------
  |  Branch (154:5): [True: 1.03k, False: 8.59M]
  ------------------
  155|   423k|    case TokenType::Nop:
  ------------------
  |  Branch (155:5): [True: 421k, False: 8.17M]
  ------------------
  156|   426k|    case TokenType::Drop:
  ------------------
  |  Branch (156:5): [True: 3.60k, False: 8.59M]
  ------------------
  157|   431k|    case TokenType::Select:
  ------------------
  |  Branch (157:5): [True: 4.46k, False: 8.59M]
  ------------------
  158|   480k|    case TokenType::Br:
  ------------------
  |  Branch (158:5): [True: 49.3k, False: 8.55M]
  ------------------
  159|   486k|    case TokenType::BrIf:
  ------------------
  |  Branch (159:5): [True: 5.72k, False: 8.59M]
  ------------------
  160|   504k|    case TokenType::BrTable:
  ------------------
  |  Branch (160:5): [True: 18.6k, False: 8.58M]
  ------------------
  161|   506k|    case TokenType::Return:
  ------------------
  |  Branch (161:5): [True: 1.63k, False: 8.59M]
  ------------------
  162|   509k|    case TokenType::ReturnCall:
  ------------------
  |  Branch (162:5): [True: 2.97k, False: 8.59M]
  ------------------
  163|   518k|    case TokenType::ReturnCallIndirect:
  ------------------
  |  Branch (163:5): [True: 8.96k, False: 8.59M]
  ------------------
  164|   536k|    case TokenType::Call:
  ------------------
  |  Branch (164:5): [True: 18.2k, False: 8.58M]
  ------------------
  165|   545k|    case TokenType::CallIndirect:
  ------------------
  |  Branch (165:5): [True: 8.95k, False: 8.59M]
  ------------------
  166|   546k|    case TokenType::CallRef:
  ------------------
  |  Branch (166:5): [True: 1.14k, False: 8.59M]
  ------------------
  167|   551k|    case TokenType::LocalGet:
  ------------------
  |  Branch (167:5): [True: 4.33k, False: 8.59M]
  ------------------
  168|   554k|    case TokenType::LocalSet:
  ------------------
  |  Branch (168:5): [True: 3.51k, False: 8.59M]
  ------------------
  169|   561k|    case TokenType::LocalTee:
  ------------------
  |  Branch (169:5): [True: 6.47k, False: 8.59M]
  ------------------
  170|   564k|    case TokenType::GlobalGet:
  ------------------
  |  Branch (170:5): [True: 3.79k, False: 8.59M]
  ------------------
  171|   567k|    case TokenType::GlobalSet:
  ------------------
  |  Branch (171:5): [True: 2.79k, False: 8.59M]
  ------------------
  172|   616k|    case TokenType::Load:
  ------------------
  |  Branch (172:5): [True: 48.2k, False: 8.55M]
  ------------------
  173|   621k|    case TokenType::Store:
  ------------------
  |  Branch (173:5): [True: 5.58k, False: 8.59M]
  ------------------
  174|  1.57M|    case TokenType::Const:
  ------------------
  |  Branch (174:5): [True: 950k, False: 7.65M]
  ------------------
  175|  1.63M|    case TokenType::Unary:
  ------------------
  |  Branch (175:5): [True: 59.2k, False: 8.54M]
  ------------------
  176|  1.68M|    case TokenType::Binary:
  ------------------
  |  Branch (176:5): [True: 58.2k, False: 8.54M]
  ------------------
  177|  1.69M|    case TokenType::Compare:
  ------------------
  |  Branch (177:5): [True: 1.48k, False: 8.59M]
  ------------------
  178|  1.69M|    case TokenType::Convert:
  ------------------
  |  Branch (178:5): [True: 6.13k, False: 8.59M]
  ------------------
  179|  1.69M|    case TokenType::MemoryCopy:
  ------------------
  |  Branch (179:5): [True: 2.16k, False: 8.59M]
  ------------------
  180|  1.70M|    case TokenType::DataDrop:
  ------------------
  |  Branch (180:5): [True: 3.48k, False: 8.59M]
  ------------------
  181|  1.70M|    case TokenType::MemoryFill:
  ------------------
  |  Branch (181:5): [True: 2.09k, False: 8.59M]
  ------------------
  182|  1.70M|    case TokenType::MemoryGrow:
  ------------------
  |  Branch (182:5): [True: 2.59k, False: 8.59M]
  ------------------
  183|  1.71M|    case TokenType::MemoryInit:
  ------------------
  |  Branch (183:5): [True: 5.54k, False: 8.59M]
  ------------------
  184|  1.73M|    case TokenType::MemorySize:
  ------------------
  |  Branch (184:5): [True: 19.3k, False: 8.58M]
  ------------------
  185|  1.73M|    case TokenType::TableCopy:
  ------------------
  |  Branch (185:5): [True: 5.74k, False: 8.59M]
  ------------------
  186|  1.74M|    case TokenType::ElemDrop:
  ------------------
  |  Branch (186:5): [True: 4.67k, False: 8.59M]
  ------------------
  187|  1.75M|    case TokenType::TableInit:
  ------------------
  |  Branch (187:5): [True: 10.9k, False: 8.58M]
  ------------------
  188|  1.75M|    case TokenType::TableGet:
  ------------------
  |  Branch (188:5): [True: 2.38k, False: 8.59M]
  ------------------
  189|  1.75M|    case TokenType::TableSet:
  ------------------
  |  Branch (189:5): [True: 2.52k, False: 8.59M]
  ------------------
  190|  1.76M|    case TokenType::TableGrow:
  ------------------
  |  Branch (190:5): [True: 5.44k, False: 8.59M]
  ------------------
  191|  1.76M|    case TokenType::TableSize:
  ------------------
  |  Branch (191:5): [True: 4.14k, False: 8.59M]
  ------------------
  192|  1.77M|    case TokenType::TableFill:
  ------------------
  |  Branch (192:5): [True: 2.51k, False: 8.59M]
  ------------------
  193|  1.78M|    case TokenType::Throw:
  ------------------
  |  Branch (193:5): [True: 11.0k, False: 8.58M]
  ------------------
  194|  1.78M|    case TokenType::ThrowRef:
  ------------------
  |  Branch (194:5): [True: 1.77k, False: 8.59M]
  ------------------
  195|  1.78M|    case TokenType::Rethrow:
  ------------------
  |  Branch (195:5): [True: 2.07k, False: 8.59M]
  ------------------
  196|  1.78M|    case TokenType::RefFunc:
  ------------------
  |  Branch (196:5): [True: 3.14k, False: 8.59M]
  ------------------
  197|  1.79M|    case TokenType::RefNull:
  ------------------
  |  Branch (197:5): [True: 3.32k, False: 8.59M]
  ------------------
  198|  1.79M|    case TokenType::RefIsNull:
  ------------------
  |  Branch (198:5): [True: 1.14k, False: 8.59M]
  ------------------
  199|  1.79M|    case TokenType::AtomicLoad:
  ------------------
  |  Branch (199:5): [True: 5.51k, False: 8.59M]
  ------------------
  200|  1.83M|    case TokenType::AtomicStore:
  ------------------
  |  Branch (200:5): [True: 39.2k, False: 8.56M]
  ------------------
  201|  1.89M|    case TokenType::AtomicRmw:
  ------------------
  |  Branch (201:5): [True: 58.1k, False: 8.54M]
  ------------------
  202|  1.92M|    case TokenType::AtomicRmwCmpxchg:
  ------------------
  |  Branch (202:5): [True: 27.6k, False: 8.57M]
  ------------------
  203|  1.92M|    case TokenType::AtomicNotify:
  ------------------
  |  Branch (203:5): [True: 2.13k, False: 8.59M]
  ------------------
  204|  1.92M|    case TokenType::AtomicFence:
  ------------------
  |  Branch (204:5): [True: 1.22k, False: 8.59M]
  ------------------
  205|  1.92M|    case TokenType::AtomicWait:
  ------------------
  |  Branch (205:5): [True: 3.02k, False: 8.59M]
  ------------------
  206|  1.94M|    case TokenType::Ternary:
  ------------------
  |  Branch (206:5): [True: 10.5k, False: 8.59M]
  ------------------
  207|  1.95M|    case TokenType::SimdLaneOp:
  ------------------
  |  Branch (207:5): [True: 12.4k, False: 8.58M]
  ------------------
  208|  1.95M|    case TokenType::SimdLoadLane:
  ------------------
  |  Branch (208:5): [True: 4.09k, False: 8.59M]
  ------------------
  209|  1.96M|    case TokenType::SimdStoreLane:
  ------------------
  |  Branch (209:5): [True: 6.50k, False: 8.59M]
  ------------------
  210|  1.97M|    case TokenType::SimdShuffleOp:
  ------------------
  |  Branch (210:5): [True: 11.4k, False: 8.58M]
  ------------------
  211|  1.97M|      return true;
  212|  6.62M|    default:
  ------------------
  |  Branch (212:5): [True: 6.62M, False: 1.97M]
  ------------------
  213|  6.62M|      return false;
  214|  8.60M|  }
  215|  8.60M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_112IsBlockInstrENS_9TokenTypeE:
  217|  6.47M|bool IsBlockInstr(TokenType token_type) {
  218|  6.47M|  switch (token_type) {
  219|  14.1k|    case TokenType::Block:
  ------------------
  |  Branch (219:5): [True: 14.1k, False: 6.46M]
  ------------------
  220|   154k|    case TokenType::Loop:
  ------------------
  |  Branch (220:5): [True: 140k, False: 6.33M]
  ------------------
  221|   451k|    case TokenType::If:
  ------------------
  |  Branch (221:5): [True: 297k, False: 6.18M]
  ------------------
  222|   640k|    case TokenType::Try:
  ------------------
  |  Branch (222:5): [True: 188k, False: 6.29M]
  ------------------
  223|   660k|    case TokenType::TryTable:
  ------------------
  |  Branch (223:5): [True: 20.1k, False: 6.45M]
  ------------------
  224|   660k|      return true;
  225|  5.81M|    default:
  ------------------
  |  Branch (225:5): [True: 5.81M, False: 660k]
  ------------------
  226|  5.81M|      return false;
  227|  6.47M|  }
  228|  6.47M|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_17IsCatchENS_9TokenTypeE:
  246|  55.4k|bool IsCatch(TokenType token_type) {
  247|  55.4k|  return token_type == TokenType::Catch || token_type == TokenType::CatchAll;
  ------------------
  |  Branch (247:10): [True: 5.89k, False: 49.5k]
  |  Branch (247:44): [True: 1.36k, False: 48.1k]
  ------------------
  248|  55.4k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_115IsTryTableCatchENSt3__15arrayINS_9TokenTypeELm2EEE:
  250|  9.42k|bool IsTryTableCatch(TokenTypePair pair) {
  251|  9.42k|  return pair[0] == TokenType::Lpar &&
  ------------------
  |  Branch (251:10): [True: 7.30k, False: 2.12k]
  ------------------
  252|  9.42k|         (pair[1] == TokenType::Catch || pair[1] == TokenType::CatchAll ||
  ------------------
  |  Branch (252:11): [True: 3.90k, False: 3.39k]
  |  Branch (252:42): [True: 606, False: 2.79k]
  ------------------
  253|  7.30k|          pair[1] == TokenType::CatchRef || pair[1] == TokenType::CatchAllRef);
  ------------------
  |  Branch (253:11): [True: 242, False: 2.54k]
  |  Branch (253:45): [True: 194, False: 2.35k]
  ------------------
  254|  9.42k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_113RemoveEscapesINSt3__120back_insert_iteratorINS2_6vectorIhNS2_9allocatorIhEEEEEEEEvRKNS4_INS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS5_ISC_EEEET_:
  147|  76.3k|void RemoveEscapes(const TextVector& texts, OutputIter out) {
  148|  76.3k|  for (std::string_view text : texts)
  ------------------
  |  Branch (148:30): [True: 39.0k, False: 76.3k]
  ------------------
  149|  39.0k|    RemoveEscapes(text, out);
  150|  76.3k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_113RemoveEscapesINSt3__120back_insert_iteratorINS2_6vectorIhNS2_9allocatorIhEEEEEEEEvNS2_17basic_string_viewIcNS2_11char_traitsIcEEEET_:
   44|  39.0k|void RemoveEscapes(std::string_view text, OutputIter dest) {
   45|       |  // Remove surrounding quotes; if any. This may be empty if the string was
   46|       |  // invalid (e.g. if it contained a bad escape sequence).
   47|  39.0k|  if (text.size() <= 2) {
  ------------------
  |  Branch (47:7): [True: 2.76k, False: 36.3k]
  ------------------
   48|  2.76k|    return;
   49|  2.76k|  }
   50|       |
   51|  36.3k|  text = text.substr(1, text.size() - 2);
   52|       |
   53|  36.3k|  const char* src = text.data();
   54|  36.3k|  const char* end = text.data() + text.size();
   55|       |
   56|  2.99M|  while (src < end) {
  ------------------
  |  Branch (56:10): [True: 2.95M, False: 36.3k]
  ------------------
   57|  2.95M|    if (*src == '\\') {
  ------------------
  |  Branch (57:9): [True: 7.92k, False: 2.94M]
  ------------------
   58|  7.92k|      src++;
   59|  7.92k|      switch (*src) {
   60|    869|        case 'n':
  ------------------
  |  Branch (60:9): [True: 869, False: 7.05k]
  ------------------
   61|    869|          *dest++ = '\n';
   62|    869|          break;
   63|    417|        case 'r':
  ------------------
  |  Branch (63:9): [True: 417, False: 7.50k]
  ------------------
   64|    417|          *dest++ = '\r';
   65|    417|          break;
   66|    651|        case 't':
  ------------------
  |  Branch (66:9): [True: 651, False: 7.27k]
  ------------------
   67|    651|          *dest++ = '\t';
   68|    651|          break;
   69|    565|        case '\\':
  ------------------
  |  Branch (69:9): [True: 565, False: 7.35k]
  ------------------
   70|    565|          *dest++ = '\\';
   71|    565|          break;
   72|    408|        case '\'':
  ------------------
  |  Branch (72:9): [True: 408, False: 7.51k]
  ------------------
   73|    408|          *dest++ = '\'';
   74|    408|          break;
   75|    467|        case '\"':
  ------------------
  |  Branch (75:9): [True: 467, False: 7.45k]
  ------------------
   76|    467|          *dest++ = '\"';
   77|    467|          break;
   78|  3.60k|        case 'u': {
  ------------------
  |  Branch (78:9): [True: 3.60k, False: 4.31k]
  ------------------
   79|       |          // The string should be validated already,
   80|       |          // so this must be a valid unicode escape sequence.
   81|  3.60k|          uint32_t digit;
   82|  3.60k|          uint32_t scalar_value = 0;
   83|       |
   84|       |          // Skip u and { characters.
   85|  3.60k|          src += 2;
   86|       |
   87|  11.1k|          do {
   88|  11.1k|            if (Succeeded(ParseHexdigit(src[0], &digit))) {
  ------------------
  |  Branch (88:17): [True: 11.1k, False: 0]
  ------------------
   89|  11.1k|              scalar_value = (scalar_value << 4) | digit;
   90|  11.1k|            } else {
   91|      0|              assert(0);
   92|      0|            }
   93|  11.1k|            src++;
   94|  11.1k|          } while (src[0] != '}');
  ------------------
  |  Branch (94:20): [True: 7.56k, False: 3.60k]
  ------------------
   95|       |
   96|       |          // Maximum value of a unicode scalar value
   97|  3.60k|          assert(scalar_value < 0x110000);
   98|       |
   99|       |          // Encode the unicode scalar value as UTF8 sequence
  100|  3.60k|          if (scalar_value < 0x80) {
  ------------------
  |  Branch (100:15): [True: 498, False: 3.10k]
  ------------------
  101|    498|            *dest++ = static_cast<uint8_t>(scalar_value);
  102|  3.10k|          } else {
  103|  3.10k|            if (scalar_value < 0x800) {
  ------------------
  |  Branch (103:17): [True: 836, False: 2.27k]
  ------------------
  104|    836|              *dest++ = static_cast<uint8_t>(0xc0 | (scalar_value >> 6));
  105|  2.27k|            } else {
  106|  2.27k|              if (scalar_value < 0x10000) {
  ------------------
  |  Branch (106:19): [True: 1.37k, False: 892]
  ------------------
  107|  1.37k|                *dest++ = static_cast<uint8_t>(0xe0 | (scalar_value >> 12));
  108|  1.37k|              } else {
  109|    892|                *dest++ = static_cast<uint8_t>(0xf0 | (scalar_value >> 18));
  110|    892|                *dest++ =
  111|    892|                    static_cast<uint8_t>(0x80 | ((scalar_value >> 12) & 0x3f));
  112|    892|              }
  113|       |
  114|  2.27k|              *dest++ =
  115|  2.27k|                  static_cast<uint8_t>(0x80 | ((scalar_value >> 6) & 0x3f));
  116|  2.27k|            }
  117|       |
  118|  3.10k|            *dest++ = static_cast<uint8_t>(0x80 | (scalar_value & 0x3f));
  119|  3.10k|          }
  120|  3.60k|          break;
  121|  3.60k|        }
  122|    942|        default: {
  ------------------
  |  Branch (122:9): [True: 942, False: 6.98k]
  ------------------
  123|       |          // The string should be validated already, so we know this is a hex
  124|       |          // sequence.
  125|    942|          uint32_t hi;
  126|    942|          uint32_t lo;
  127|    942|          if (Succeeded(ParseHexdigit(src[0], &hi)) &&
  ------------------
  |  Branch (127:15): [True: 942, False: 0]
  ------------------
  128|    942|              Succeeded(ParseHexdigit(src[1], &lo))) {
  ------------------
  |  Branch (128:15): [True: 942, False: 0]
  ------------------
  129|    942|            *dest++ = (hi << 4) | lo;
  130|    942|          } else {
  131|      0|            assert(0);
  132|      0|          }
  133|    942|          src++;
  134|    942|          break;
  135|    942|        }
  136|  7.92k|      }
  137|  7.92k|      src++;
  138|  2.94M|    } else {
  139|  2.94M|      *dest++ = *src++;
  140|  2.94M|    }
  141|  2.95M|  }
  142|  36.3k|}
wast-parser.cc:_ZN4wabt12_GLOBAL__N_113RemoveEscapesINSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvNS2_17basic_string_viewIcS6_EET_:
   44|   499k|void RemoveEscapes(std::string_view text, OutputIter dest) {
   45|       |  // Remove surrounding quotes; if any. This may be empty if the string was
   46|       |  // invalid (e.g. if it contained a bad escape sequence).
   47|   499k|  if (text.size() <= 2) {
  ------------------
  |  Branch (47:7): [True: 458k, False: 41.0k]
  ------------------
   48|   458k|    return;
   49|   458k|  }
   50|       |
   51|  41.0k|  text = text.substr(1, text.size() - 2);
   52|       |
   53|  41.0k|  const char* src = text.data();
   54|  41.0k|  const char* end = text.data() + text.size();
   55|       |
   56|  6.23M|  while (src < end) {
  ------------------
  |  Branch (56:10): [True: 6.18M, False: 41.0k]
  ------------------
   57|  6.18M|    if (*src == '\\') {
  ------------------
  |  Branch (57:9): [True: 3.89k, False: 6.18M]
  ------------------
   58|  3.89k|      src++;
   59|  3.89k|      switch (*src) {
   60|    453|        case 'n':
  ------------------
  |  Branch (60:9): [True: 453, False: 3.44k]
  ------------------
   61|    453|          *dest++ = '\n';
   62|    453|          break;
   63|    346|        case 'r':
  ------------------
  |  Branch (63:9): [True: 346, False: 3.54k]
  ------------------
   64|    346|          *dest++ = '\r';
   65|    346|          break;
   66|    221|        case 't':
  ------------------
  |  Branch (66:9): [True: 221, False: 3.67k]
  ------------------
   67|    221|          *dest++ = '\t';
   68|    221|          break;
   69|    474|        case '\\':
  ------------------
  |  Branch (69:9): [True: 474, False: 3.42k]
  ------------------
   70|    474|          *dest++ = '\\';
   71|    474|          break;
   72|    315|        case '\'':
  ------------------
  |  Branch (72:9): [True: 315, False: 3.58k]
  ------------------
   73|    315|          *dest++ = '\'';
   74|    315|          break;
   75|    374|        case '\"':
  ------------------
  |  Branch (75:9): [True: 374, False: 3.52k]
  ------------------
   76|    374|          *dest++ = '\"';
   77|    374|          break;
   78|  1.30k|        case 'u': {
  ------------------
  |  Branch (78:9): [True: 1.30k, False: 2.59k]
  ------------------
   79|       |          // The string should be validated already,
   80|       |          // so this must be a valid unicode escape sequence.
   81|  1.30k|          uint32_t digit;
   82|  1.30k|          uint32_t scalar_value = 0;
   83|       |
   84|       |          // Skip u and { characters.
   85|  1.30k|          src += 2;
   86|       |
   87|  4.63k|          do {
   88|  4.63k|            if (Succeeded(ParseHexdigit(src[0], &digit))) {
  ------------------
  |  Branch (88:17): [True: 4.63k, False: 0]
  ------------------
   89|  4.63k|              scalar_value = (scalar_value << 4) | digit;
   90|  4.63k|            } else {
   91|      0|              assert(0);
   92|      0|            }
   93|  4.63k|            src++;
   94|  4.63k|          } while (src[0] != '}');
  ------------------
  |  Branch (94:20): [True: 3.33k, False: 1.30k]
  ------------------
   95|       |
   96|       |          // Maximum value of a unicode scalar value
   97|  1.30k|          assert(scalar_value < 0x110000);
   98|       |
   99|       |          // Encode the unicode scalar value as UTF8 sequence
  100|  1.30k|          if (scalar_value < 0x80) {
  ------------------
  |  Branch (100:15): [True: 219, False: 1.08k]
  ------------------
  101|    219|            *dest++ = static_cast<uint8_t>(scalar_value);
  102|  1.08k|          } else {
  103|  1.08k|            if (scalar_value < 0x800) {
  ------------------
  |  Branch (103:17): [True: 214, False: 867]
  ------------------
  104|    214|              *dest++ = static_cast<uint8_t>(0xc0 | (scalar_value >> 6));
  105|    867|            } else {
  106|    867|              if (scalar_value < 0x10000) {
  ------------------
  |  Branch (106:19): [True: 280, False: 587]
  ------------------
  107|    280|                *dest++ = static_cast<uint8_t>(0xe0 | (scalar_value >> 12));
  108|    587|              } else {
  109|    587|                *dest++ = static_cast<uint8_t>(0xf0 | (scalar_value >> 18));
  110|    587|                *dest++ =
  111|    587|                    static_cast<uint8_t>(0x80 | ((scalar_value >> 12) & 0x3f));
  112|    587|              }
  113|       |
  114|    867|              *dest++ =
  115|    867|                  static_cast<uint8_t>(0x80 | ((scalar_value >> 6) & 0x3f));
  116|    867|            }
  117|       |
  118|  1.08k|            *dest++ = static_cast<uint8_t>(0x80 | (scalar_value & 0x3f));
  119|  1.08k|          }
  120|  1.30k|          break;
  121|  1.30k|        }
  122|    412|        default: {
  ------------------
  |  Branch (122:9): [True: 412, False: 3.48k]
  ------------------
  123|       |          // The string should be validated already, so we know this is a hex
  124|       |          // sequence.
  125|    412|          uint32_t hi;
  126|    412|          uint32_t lo;
  127|    412|          if (Succeeded(ParseHexdigit(src[0], &hi)) &&
  ------------------
  |  Branch (127:15): [True: 412, False: 0]
  ------------------
  128|    412|              Succeeded(ParseHexdigit(src[1], &lo))) {
  ------------------
  |  Branch (128:15): [True: 412, False: 0]
  ------------------
  129|    412|            *dest++ = (hi << 4) | lo;
  130|    412|          } else {
  131|      0|            assert(0);
  132|      0|          }
  133|    412|          src++;
  134|    412|          break;
  135|    412|        }
  136|  3.89k|      }
  137|  3.89k|      src++;
  138|  6.18M|    } else {
  139|  6.18M|      *dest++ = *src++;
  140|  6.18M|    }
  141|  6.18M|  }
  142|  41.0k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE9EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  22.2k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  22.2k|  Var var;
 2186|  22.2k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  22.2k|  do {                              \
  |  |   56|  22.2k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 3.41k, False: 18.8k]
  |  |  ------------------
  |  |   57|  3.41k|      return ::wabt::Result::Error; \
  |  |   58|  3.41k|    }                               \
  |  |   59|  22.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  18.8k|  out_expr->reset(new T(var, loc));
 2188|  18.8k|  return Result::Ok;
 2189|  22.2k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE10EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  2.54k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  2.54k|  Var var;
 2186|  2.54k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  2.54k|  do {                              \
  |  |   56|  2.54k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 376, False: 2.16k]
  |  |  ------------------
  |  |   57|    376|      return ::wabt::Result::Error; \
  |  |   58|    376|    }                               \
  |  |   59|  2.54k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  2.16k|  out_expr->reset(new T(var, loc));
 2188|  2.16k|  return Result::Ok;
 2189|  2.54k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE12EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  8.78k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  8.78k|  Var var;
 2186|  8.78k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  8.78k|  do {                              \
  |  |   56|  8.78k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 632, False: 8.15k]
  |  |  ------------------
  |  |   57|    632|      return ::wabt::Result::Error; \
  |  |   58|    632|    }                               \
  |  |   59|  8.78k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  8.15k|  out_expr->reset(new T(var, loc));
 2188|  8.15k|  return Result::Ok;
 2189|  8.78k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE40EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.28k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.28k|  Var var;
 2186|  1.28k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.28k|  do {                              \
  |  |   56|  1.28k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 391, False: 889]
  |  |  ------------------
  |  |   57|    391|      return ::wabt::Result::Error; \
  |  |   58|    391|    }                               \
  |  |   59|  1.28k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|    889|  out_expr->reset(new T(var, loc));
 2188|    889|  return Result::Ok;
 2189|  1.28k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE24EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.57k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.57k|  Var var;
 2186|  1.57k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.57k|  do {                              \
  |  |   56|  1.57k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 338, False: 1.23k]
  |  |  ------------------
  |  |   57|    338|      return ::wabt::Result::Error; \
  |  |   58|    338|    }                               \
  |  |   59|  1.57k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  1.23k|  out_expr->reset(new T(var, loc));
 2188|  1.23k|  return Result::Ok;
 2189|  1.57k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE25EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.46k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.46k|  Var var;
 2186|  1.46k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.46k|  do {                              \
  |  |   56|  1.46k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 342, False: 1.12k]
  |  |  ------------------
  |  |   57|    342|      return ::wabt::Result::Error; \
  |  |   58|    342|    }                               \
  |  |   59|  1.46k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  1.12k|  out_expr->reset(new T(var, loc));
 2188|  1.12k|  return Result::Ok;
 2189|  1.46k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE26EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  2.29k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  2.29k|  Var var;
 2186|  2.29k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  2.29k|  do {                              \
  |  |   56|  2.29k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 382, False: 1.91k]
  |  |  ------------------
  |  |   57|    382|      return ::wabt::Result::Error; \
  |  |   58|    382|    }                               \
  |  |   59|  2.29k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  1.91k|  out_expr->reset(new T(var, loc));
 2188|  1.91k|  return Result::Ok;
 2189|  2.29k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE20EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.32k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.32k|  Var var;
 2186|  1.32k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.32k|  do {                              \
  |  |   56|  1.32k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 388, False: 932]
  |  |  ------------------
  |  |   57|    388|      return ::wabt::Result::Error; \
  |  |   58|    388|    }                               \
  |  |   59|  1.32k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|    932|  out_expr->reset(new T(var, loc));
 2188|    932|  return Result::Ok;
 2189|  1.32k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE21EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.21k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.21k|  Var var;
 2186|  1.21k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.21k|  do {                              \
  |  |   56|  1.21k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 352, False: 862]
  |  |  ------------------
  |  |   57|    352|      return ::wabt::Result::Error; \
  |  |   58|    352|    }                               \
  |  |   59|  1.21k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|    862|  out_expr->reset(new T(var, loc));
 2188|    862|  return Result::Ok;
 2189|  1.21k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE23EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  13.1k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  13.1k|  Opcode opcode = token.opcode();
 2224|  13.1k|  Var memidx;
 2225|  13.1k|  Address offset;
 2226|  13.1k|  Address align;
 2227|  13.1k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  13.1k|  do {                              \
  |  |   56|  13.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 564, False: 12.6k]
  |  |  ------------------
  |  |   57|    564|      return ::wabt::Result::Error; \
  |  |   58|    564|    }                               \
  |  |   59|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  12.6k|  ParseOffsetOpt(&offset);
 2229|  12.6k|  ParseAlignOpt(&align);
 2230|  12.6k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  12.6k|  return Result::Ok;
 2232|  13.1k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE49EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  1.72k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  1.72k|  Opcode opcode = token.opcode();
 2224|  1.72k|  Var memidx;
 2225|  1.72k|  Address offset;
 2226|  1.72k|  Address align;
 2227|  1.72k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  1.72k|  do {                              \
  |  |   56|  1.72k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 227, False: 1.49k]
  |  |  ------------------
  |  |   57|    227|      return ::wabt::Result::Error; \
  |  |   58|    227|    }                               \
  |  |   59|  1.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  1.49k|  ParseOffsetOpt(&offset);
 2229|  1.49k|  ParseAlignOpt(&align);
 2230|  1.49k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  1.49k|  return Result::Ok;
 2232|  1.72k|}
_ZN4wabt10WastParser21ParseMemoryBinaryExprINS_16MemoryBinaryExprILNS_8ExprTypeE28EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2287|    870|                                         std::unique_ptr<Expr>* out_expr) {
 2288|    870|  Var destmemidx;
 2289|    870|  Var srcmemidx;
 2290|    870|  CHECK_RESULT(ParseMemidx(loc, &destmemidx));
  ------------------
  |  |   55|    870|  do {                              \
  |  |   56|    870|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 197, False: 673]
  |  |  ------------------
  |  |   57|    197|      return ::wabt::Result::Error; \
  |  |   58|    197|    }                               \
  |  |   59|    870|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2291|    673|  CHECK_RESULT(ParseMemidx(loc, &srcmemidx));
  ------------------
  |  |   55|    673|  do {                              \
  |  |   56|    673|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 673]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|    673|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2292|    673|  out_expr->reset(new T(destmemidx, srcmemidx, loc));
 2293|    673|  return Result::Ok;
 2294|    673|}
_ZN4wabt10WastParser15ParseMemoryExprINS_10MemoryExprILNS_8ExprTypeE30EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2278|    721|                                   std::unique_ptr<Expr>* out_expr) {
 2279|    721|  Var memidx;
 2280|    721|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|    721|  do {                              \
  |  |   56|    721|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 311, False: 410]
  |  |  ------------------
  |  |   57|    311|      return ::wabt::Result::Error; \
  |  |   58|    311|    }                               \
  |  |   59|    721|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2281|    410|  out_expr->reset(new T(memidx, loc));
 2282|    410|  return Result::Ok;
 2283|    721|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE29EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.45k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.45k|  Var var;
 2186|  1.45k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.45k|  do {                              \
  |  |   56|  1.45k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 417, False: 1.04k]
  |  |  ------------------
  |  |   57|    417|      return ::wabt::Result::Error; \
  |  |   58|    417|    }                               \
  |  |   59|  1.45k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  1.04k|  out_expr->reset(new T(var, loc));
 2188|  1.04k|  return Result::Ok;
 2189|  1.45k|}
_ZN4wabt10WastParser19ParseMemoryInstrVarINS_13MemoryVarExprILNS_8ExprTypeE32EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2193|  2.06k|                                       std::unique_ptr<Expr>* out_expr) {
 2194|  2.06k|  Var memidx;
 2195|  2.06k|  Var var;
 2196|  2.06k|  if (PeekMatchLpar(TokenType::Memory)) {
  ------------------
  |  Branch (2196:7): [True: 244, False: 1.81k]
  ------------------
 2197|    244|    if (!options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (2197:9): [True: 244, False: 0]
  ------------------
 2198|    244|      Error(loc, "Specifying memory variable is not allowed");
 2199|    244|      return Result::Error;
 2200|    244|    }
 2201|      0|    CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2202|      0|    CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2203|      0|    out_expr->reset(new T(var, memidx, loc));
 2204|  1.81k|  } else {
 2205|  1.81k|    CHECK_RESULT(ParseVar(&memidx));
  ------------------
  |  |   55|  1.81k|  do {                              \
  |  |   56|  1.81k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 424, False: 1.39k]
  |  |  ------------------
  |  |   57|    424|      return ::wabt::Result::Error; \
  |  |   58|    424|    }                               \
  |  |   59|  1.81k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2206|  1.39k|    if (ParseVarOpt(&var, Var(0, loc))) {
  ------------------
  |  Branch (2206:9): [True: 483, False: 909]
  ------------------
 2207|    483|      if (!options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (2207:11): [True: 483, False: 0]
  ------------------
 2208|    483|        Error(loc, "Specifiying memory variable is not allowed");
 2209|    483|        return Result::Error;
 2210|    483|      }
 2211|      0|      out_expr->reset(new T(var, memidx, loc));
 2212|    909|    } else {
 2213|    909|      out_expr->reset(new T(memidx, var, loc));
 2214|    909|    }
 2215|  1.39k|  }
 2216|    909|  return Result::Ok;
 2217|  2.06k|}
_ZN4wabt10WastParser15ParseMemoryExprINS_10MemoryExprILNS_8ExprTypeE33EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2278|  6.00k|                                   std::unique_ptr<Expr>* out_expr) {
 2279|  6.00k|  Var memidx;
 2280|  6.00k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  6.00k|  do {                              \
  |  |   56|  6.00k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 227, False: 5.77k]
  |  |  ------------------
  |  |   57|    227|      return ::wabt::Result::Error; \
  |  |   58|    227|    }                               \
  |  |   59|  6.00k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2281|  5.77k|  out_expr->reset(new T(memidx, loc));
 2282|  5.77k|  return Result::Ok;
 2283|  6.00k|}
_ZN4wabt10WastParser15ParseMemoryExprINS_10MemoryExprILNS_8ExprTypeE31EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2278|    956|                                   std::unique_ptr<Expr>* out_expr) {
 2279|    956|  Var memidx;
 2280|    956|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|    956|  do {                              \
  |  |   56|    956|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 304, False: 652]
  |  |  ------------------
  |  |   57|    304|      return ::wabt::Result::Error; \
  |  |   58|    304|    }                               \
  |  |   59|    956|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2281|    652|  out_expr->reset(new T(memidx, loc));
 2282|    652|  return Result::Ok;
 2283|    956|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE51EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.79k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.79k|  Var var;
 2186|  1.79k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.79k|  do {                              \
  |  |   56|  1.79k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 388, False: 1.40k]
  |  |  ------------------
  |  |   57|    388|      return ::wabt::Result::Error; \
  |  |   58|    388|    }                               \
  |  |   59|  1.79k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  1.40k|  out_expr->reset(new T(var, loc));
 2188|  1.40k|  return Result::Ok;
 2189|  1.79k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE36EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  1.32k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  1.32k|  Var var;
 2186|  1.32k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  1.32k|  do {                              \
  |  |   56|  1.32k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 425, False: 895]
  |  |  ------------------
  |  |   57|    425|      return ::wabt::Result::Error; \
  |  |   58|    425|    }                               \
  |  |   59|  1.32k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|    895|  out_expr->reset(new T(var, loc));
 2188|    895|  return Result::Ok;
 2189|  1.32k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE59EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|  4.60k|                                      std::unique_ptr<Expr>* out_expr) {
 2185|  4.60k|  Var var;
 2186|  4.60k|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|  4.60k|  do {                              \
  |  |   56|  4.60k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 1.40k, False: 3.20k]
  |  |  ------------------
  |  |   57|  1.40k|      return ::wabt::Result::Error; \
  |  |   58|  1.40k|    }                               \
  |  |   59|  4.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|  3.20k|  out_expr->reset(new T(var, loc));
 2188|  3.20k|  return Result::Ok;
 2189|  4.60k|}
_ZN4wabt10WastParser18ParsePlainInstrVarINS_7VarExprILNS_8ExprTypeE38EEEEENS_6ResultENS_8LocationEPNSt3__110unique_ptrINS_4ExprENS7_14default_deleteIS9_EEEE:
 2184|    743|                                      std::unique_ptr<Expr>* out_expr) {
 2185|    743|  Var var;
 2186|    743|  CHECK_RESULT(ParseVar(&var));
  ------------------
  |  |   55|    743|  do {                              \
  |  |   56|    743|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 465, False: 278]
  |  |  ------------------
  |  |   57|    465|      return ::wabt::Result::Error; \
  |  |   58|    465|    }                               \
  |  |   59|    743|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2187|    278|  out_expr->reset(new T(var, loc));
 2188|    278|  return Result::Ok;
 2189|    743|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE4EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|    611|                                       std::unique_ptr<Expr>* out_expr) {
 2223|    611|  Opcode opcode = token.opcode();
 2224|    611|  Var memidx;
 2225|    611|  Address offset;
 2226|    611|  Address align;
 2227|    611|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|    611|  do {                              \
  |  |   56|    611|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 195, False: 416]
  |  |  ------------------
  |  |   57|    195|      return ::wabt::Result::Error; \
  |  |   58|    195|    }                               \
  |  |   59|    611|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|    416|  ParseOffsetOpt(&offset);
 2229|    416|  ParseAlignOpt(&align);
 2230|    416|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|    416|  return Result::Ok;
 2232|    611|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE6EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  1.04k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  1.04k|  Opcode opcode = token.opcode();
 2224|  1.04k|  Var memidx;
 2225|  1.04k|  Address offset;
 2226|  1.04k|  Address align;
 2227|  1.04k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  1.04k|  do {                              \
  |  |   56|  1.04k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 505, False: 539]
  |  |  ------------------
  |  |   57|    505|      return ::wabt::Result::Error; \
  |  |   58|    505|    }                               \
  |  |   59|  1.04k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|    539|  ParseOffsetOpt(&offset);
 2229|    539|  ParseAlignOpt(&align);
 2230|    539|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|    539|  return Result::Ok;
 2232|  1.04k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE0EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  2.07k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  2.07k|  Opcode opcode = token.opcode();
 2224|  2.07k|  Var memidx;
 2225|  2.07k|  Address offset;
 2226|  2.07k|  Address align;
 2227|  2.07k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  2.07k|  do {                              \
  |  |   56|  2.07k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 201, False: 1.87k]
  |  |  ------------------
  |  |   57|    201|      return ::wabt::Result::Error; \
  |  |   58|    201|    }                               \
  |  |   59|  2.07k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  1.87k|  ParseOffsetOpt(&offset);
 2229|  1.87k|  ParseAlignOpt(&align);
 2230|  1.87k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  1.87k|  return Result::Ok;
 2232|  2.07k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE3EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  13.3k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  13.3k|  Opcode opcode = token.opcode();
 2224|  13.3k|  Var memidx;
 2225|  13.3k|  Address offset;
 2226|  13.3k|  Address align;
 2227|  13.3k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  13.3k|  do {                              \
  |  |   56|  13.3k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 11.5k, False: 1.72k]
  |  |  ------------------
  |  |   57|  11.5k|      return ::wabt::Result::Error; \
  |  |   58|  11.5k|    }                               \
  |  |   59|  13.3k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  1.72k|  ParseOffsetOpt(&offset);
 2229|  1.72k|  ParseAlignOpt(&align);
 2230|  1.72k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  1.72k|  return Result::Ok;
 2232|  13.3k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE1EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  20.1k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  20.1k|  Opcode opcode = token.opcode();
 2224|  20.1k|  Var memidx;
 2225|  20.1k|  Address offset;
 2226|  20.1k|  Address align;
 2227|  20.1k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  20.1k|  do {                              \
  |  |   56|  20.1k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 790, False: 19.3k]
  |  |  ------------------
  |  |   57|    790|      return ::wabt::Result::Error; \
  |  |   58|    790|    }                               \
  |  |   59|  20.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  19.3k|  ParseOffsetOpt(&offset);
 2229|  19.3k|  ParseAlignOpt(&align);
 2230|  19.3k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  19.3k|  return Result::Ok;
 2232|  20.1k|}
_ZN4wabt10WastParser19ParseLoadStoreInstrINS_13LoadStoreExprILNS_8ExprTypeE2EEEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS8_14default_deleteISA_EEEE:
 2222|  10.4k|                                       std::unique_ptr<Expr>* out_expr) {
 2223|  10.4k|  Opcode opcode = token.opcode();
 2224|  10.4k|  Var memidx;
 2225|  10.4k|  Address offset;
 2226|  10.4k|  Address align;
 2227|  10.4k|  CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|  10.4k|  do {                              \
  |  |   56|  10.4k|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 359, False: 10.0k]
  |  |  ------------------
  |  |   57|    359|      return ::wabt::Result::Error; \
  |  |   58|    359|    }                               \
  |  |   59|  10.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2228|  10.0k|  ParseOffsetOpt(&offset);
 2229|  10.0k|  ParseAlignOpt(&align);
 2230|  10.0k|  out_expr->reset(new T(opcode, memidx, align, offset, loc));
 2231|  10.0k|  return Result::Ok;
 2232|  10.4k|}
_ZN4wabt10WastParser23ParseSIMDLoadStoreInstrINS_16SimdLoadLaneExprEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS6_14default_deleteIS8_EEEE:
 2237|  1.28k|                                           std::unique_ptr<Expr>* out_expr) {
 2238|  1.28k|  ErrorUnlessOpcodeEnabled(token);
 2239|       |
 2240|  1.28k|  Var memidx(0, loc);
 2241|       |
 2242|  1.28k|  if (options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (2242:7): [True: 0, False: 1.28k]
  ------------------
 2243|       |    // We have to be a little careful when reading the memeory index.
 2244|       |    // If there is just a single integer folloing the instruction that
 2245|       |    // represents the lane index, so we check for either a pair of intergers
 2246|       |    // or an integers followed by offset= or align=.
 2247|      0|    bool try_read_mem_index = true;
 2248|      0|    if (PeekMatch(TokenType::Nat)) {
  ------------------
  |  Branch (2248:9): [True: 0, False: 0]
  ------------------
 2249|       |      // The next token could be a memory index or a lane index
 2250|      0|      if (!PeekMatch(TokenType::OffsetEqNat, 1) &&
  ------------------
  |  Branch (2250:11): [True: 0, False: 0]
  ------------------
 2251|      0|          !PeekMatch(TokenType::AlignEqNat, 1) &&
  ------------------
  |  Branch (2251:11): [True: 0, False: 0]
  ------------------
 2252|      0|          !PeekMatch(TokenType::Nat, 1)) {
  ------------------
  |  Branch (2252:11): [True: 0, False: 0]
  ------------------
 2253|      0|        try_read_mem_index = false;
 2254|      0|      }
 2255|      0|    }
 2256|      0|    if (try_read_mem_index) {
  ------------------
  |  Branch (2256:9): [True: 0, False: 0]
  ------------------
 2257|      0|      CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2258|      0|    }
 2259|      0|  }
 2260|  1.28k|  Address offset;
 2261|  1.28k|  Address align;
 2262|  1.28k|  ParseOffsetOpt(&offset);
 2263|  1.28k|  ParseAlignOpt(&align);
 2264|       |
 2265|  1.28k|  uint64_t lane_idx = 0;
 2266|  1.28k|  Result result = ParseSimdLane(loc, &lane_idx);
 2267|       |
 2268|  1.28k|  if (Failed(result)) {
  ------------------
  |  Branch (2268:7): [True: 936, False: 345]
  ------------------
 2269|    936|    return Result::Error;
 2270|    936|  }
 2271|       |
 2272|    345|  out_expr->reset(new T(token.opcode(), memidx, align, offset, lane_idx, loc));
 2273|    345|  return Result::Ok;
 2274|  1.28k|}
_ZN4wabt10WastParser23ParseSIMDLoadStoreInstrINS_17SimdStoreLaneExprEEENS_6ResultENS_8LocationENS_5TokenEPNSt3__110unique_ptrINS_4ExprENS6_14default_deleteIS8_EEEE:
 2237|  2.15k|                                           std::unique_ptr<Expr>* out_expr) {
 2238|  2.15k|  ErrorUnlessOpcodeEnabled(token);
 2239|       |
 2240|  2.15k|  Var memidx(0, loc);
 2241|       |
 2242|  2.15k|  if (options_->features.multi_memory_enabled()) {
  ------------------
  |  Branch (2242:7): [True: 0, False: 2.15k]
  ------------------
 2243|       |    // We have to be a little careful when reading the memeory index.
 2244|       |    // If there is just a single integer folloing the instruction that
 2245|       |    // represents the lane index, so we check for either a pair of intergers
 2246|       |    // or an integers followed by offset= or align=.
 2247|      0|    bool try_read_mem_index = true;
 2248|      0|    if (PeekMatch(TokenType::Nat)) {
  ------------------
  |  Branch (2248:9): [True: 0, False: 0]
  ------------------
 2249|       |      // The next token could be a memory index or a lane index
 2250|      0|      if (!PeekMatch(TokenType::OffsetEqNat, 1) &&
  ------------------
  |  Branch (2250:11): [True: 0, False: 0]
  ------------------
 2251|      0|          !PeekMatch(TokenType::AlignEqNat, 1) &&
  ------------------
  |  Branch (2251:11): [True: 0, False: 0]
  ------------------
 2252|      0|          !PeekMatch(TokenType::Nat, 1)) {
  ------------------
  |  Branch (2252:11): [True: 0, False: 0]
  ------------------
 2253|      0|        try_read_mem_index = false;
 2254|      0|      }
 2255|      0|    }
 2256|      0|    if (try_read_mem_index) {
  ------------------
  |  Branch (2256:9): [True: 0, False: 0]
  ------------------
 2257|      0|      CHECK_RESULT(ParseMemidx(loc, &memidx));
  ------------------
  |  |   55|      0|  do {                              \
  |  |   56|      0|    if (Failed(expr)) {             \
  |  |  ------------------
  |  |  |  Branch (56:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   57|      0|      return ::wabt::Result::Error; \
  |  |   58|      0|    }                               \
  |  |   59|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (59:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2258|      0|    }
 2259|      0|  }
 2260|  2.15k|  Address offset;
 2261|  2.15k|  Address align;
 2262|  2.15k|  ParseOffsetOpt(&offset);
 2263|  2.15k|  ParseAlignOpt(&align);
 2264|       |
 2265|  2.15k|  uint64_t lane_idx = 0;
 2266|  2.15k|  Result result = ParseSimdLane(loc, &lane_idx);
 2267|       |
 2268|  2.15k|  if (Failed(result)) {
  ------------------
  |  Branch (2268:7): [True: 1.60k, False: 547]
  ------------------
 2269|  1.60k|    return Result::Error;
 2270|  1.60k|  }
 2271|       |
 2272|    547|  out_expr->reset(new T(token.opcode(), memidx, align, offset, lane_idx, loc));
 2273|    547|  return Result::Ok;
 2274|  2.15k|}
wast-parser.cc:_ZZNK4wabt10WastParser8HasErrorEvENK3$_0clINS_5ErrorEEEDaRKT_:
 3884|  2.56k|  return std::any_of(errors_->begin(), errors_->end(), [](const auto& x) {
 3885|  2.56k|    return x.error_level == ErrorLevel::Error;
 3886|  2.56k|  });

LLVMFuzzerTestOneInput:
   19|  23.2k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   20|  23.2k|  wabt::Errors Lexerrors;
   21|  23.2k|  std::unique_ptr<wabt::WastLexer> lexer =
   22|  23.2k|      wabt::WastLexer::CreateBufferLexer("fake_file", data, size, &Lexerrors);
   23|       |
   24|  23.2k|  if (!lexer) {
  ------------------
  |  Branch (24:7): [True: 0, False: 23.2k]
  ------------------
   25|      0|    return 0;
   26|      0|  }
   27|       |
   28|  23.2k|  std::unique_ptr<wabt::Module> module;
   29|  23.2k|  wabt::Errors errors;
   30|  23.2k|  wabt::Features features;
   31|  23.2k|  wabt::WastParseOptions parse_wast_options(features);
   32|  23.2k|  ParseWatModule(lexer.get(), &module, &errors, &parse_wast_options);
   33|       |
   34|  23.2k|  return 0;
   35|  23.2k|}