gen-s-parser.inc

// DO NOT EDIT! This file generated by scripts/gen-s-parser.py

// clang-format off

// NOLINTBEGIN

auto op = *keyword;
char buf[36] = {};
// Ensure we do not copy more than the buffer can hold
if (op.size() >= sizeof(buf)) {
  goto parse_error;
}
memcpy(buf, op.data(), op.size());
switch (buf[0]) {
  case 'a': {
    switch (buf[1]) {
      case 'n':
        if (op == "any.convert_extern"sv) {
          CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern));
          return Ok{};
        }
        goto parse_error;
      case 'r': {
        switch (buf[6]) {
          case 'a': {
            switch (buf[13]) {
              case 'g': {
                switch (buf[16]) {
                  case '\0':
                    if (op == "array.atomic.get"sv) {
                      CHECK_ERR(makeAtomicArrayGet(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[17]) {
                      case 's':
                        if (op == "array.atomic.get_s"sv) {
                          CHECK_ERR(makeAtomicArrayGet(ctx, pos, annotations, true));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "array.atomic.get_u"sv) {
                          CHECK_ERR(makeAtomicArrayGet(ctx, pos, annotations, false));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'r': {
                switch (buf[17]) {
                  case 'a': {
                    switch (buf[18]) {
                      case 'd':
                        if (op == "array.atomic.rmw.add"sv) {
                          CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWAdd));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'n':
                        if (op == "array.atomic.rmw.and"sv) {
                          CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWAnd));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'c':
                    if (op == "array.atomic.rmw.cmpxchg"sv) {
                      CHECK_ERR(makeArrayCmpxchg(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o':
                    if (op == "array.atomic.rmw.or"sv) {
                      CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWOr));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "array.atomic.rmw.sub"sv) {
                      CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWSub));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x': {
                    switch (buf[18]) {
                      case 'c':
                        if (op == "array.atomic.rmw.xchg"sv) {
                          CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWXchg));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'o':
                        if (op == "array.atomic.rmw.xor"sv) {
                          CHECK_ERR(makeArrayRMW(ctx, pos, annotations, RMWXor));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 's':
                if (op == "array.atomic.set"sv) {
                  CHECK_ERR(makeAtomicArraySet(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'c':
            if (op == "array.copy"sv) {
              CHECK_ERR(makeArrayCopy(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'f':
            if (op == "array.fill"sv) {
              CHECK_ERR(makeArrayFill(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'g': {
            switch (buf[9]) {
              case '\0':
                if (op == "array.get"sv) {
                  CHECK_ERR(makeArrayGet(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case '_': {
                switch (buf[10]) {
                  case 's':
                    if (op == "array.get_s"sv) {
                      CHECK_ERR(makeArrayGet(ctx, pos, annotations, true));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "array.get_u"sv) {
                      CHECK_ERR(makeArrayGet(ctx, pos, annotations, false));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'i': {
            switch (buf[11]) {
              case 'd':
                if (op == "array.init_data"sv) {
                  CHECK_ERR(makeArrayInitData(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case 'e':
                if (op == "array.init_elem"sv) {
                  CHECK_ERR(makeArrayInitElem(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'l':
            if (op == "array.len"sv) {
              CHECK_ERR(makeArrayLen(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'n': {
            switch (buf[9]) {
              case '\0':
                if (op == "array.new"sv) {
                  CHECK_ERR(makeArrayNew(ctx, pos, annotations, false));
                  return Ok{};
                }
                goto parse_error;
              case '_': {
                switch (buf[10]) {
                  case 'd': {
                    switch (buf[11]) {
                      case 'a':
                        if (op == "array.new_data"sv) {
                          CHECK_ERR(makeArrayNewData(ctx, pos, annotations));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'e':
                        if (op == "array.new_default"sv) {
                          CHECK_ERR(makeArrayNew(ctx, pos, annotations, true));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'e':
                    if (op == "array.new_elem"sv) {
                      CHECK_ERR(makeArrayNewElem(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'f':
                    if (op == "array.new_fixed"sv) {
                      CHECK_ERR(makeArrayNewFixed(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 's':
            if (op == "array.set"sv) {
              CHECK_ERR(makeArraySet(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case 't':
        if (op == "atomic.fence"sv) {
          CHECK_ERR(makeAtomicFence(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'b': {
    switch (buf[2]) {
      case '\0':
        if (op == "br"sv) {
          CHECK_ERR(makeBreak(ctx, pos, annotations, false));
          return Ok{};
        }
        goto parse_error;
      case '_': {
        switch (buf[3]) {
          case 'i':
            if (op == "br_if"sv) {
              CHECK_ERR(makeBreak(ctx, pos, annotations, true));
              return Ok{};
            }
            goto parse_error;
          case 'o': {
            switch (buf[6]) {
              case 'c': {
                switch (buf[10]) {
                  case '\0':
                    if (op == "br_on_cast"sv) {
                      CHECK_ERR(makeBrOnCast(ctx, pos, annotations, BrOnCast));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[11]) {
                      case 'd': {
                        switch (buf[18]) {
                          case '\0':
                            if (op == "br_on_cast_desc_eq"sv) {
                              CHECK_ERR(makeBrOnCast(ctx, pos, annotations, BrOnCastDescEq));
                              return Ok{};
                            }
                            goto parse_error;
                          case '_':
                            if (op == "br_on_cast_desc_eq_fail"sv) {
                              CHECK_ERR(makeBrOnCast(ctx, pos, annotations, BrOnCastDescEqFail));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'f':
                        if (op == "br_on_cast_fail"sv) {
                          CHECK_ERR(makeBrOnCast(ctx, pos, annotations, BrOnCastFail));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[7]) {
                  case 'o':
                    if (op == "br_on_non_null"sv) {
                      CHECK_ERR(makeBrOnNull(ctx, pos, annotations, true));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "br_on_null"sv) {
                      CHECK_ERR(makeBrOnNull(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 't':
            if (op == "br_table"sv) {
              CHECK_ERR(makeBreakTable(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 'c': {
    switch (buf[1]) {
      case 'a': {
        switch (buf[4]) {
          case '\0':
            if (op == "call"sv) {
              CHECK_ERR(makeCall(ctx, pos, annotations, /*isReturn=*/false));
              return Ok{};
            }
            goto parse_error;
          case '_': {
            switch (buf[5]) {
              case 'i':
                if (op == "call_indirect"sv) {
                  CHECK_ERR(makeCallIndirect(ctx, pos, annotations, /*isReturn=*/false));
                  return Ok{};
                }
                goto parse_error;
              case 'r':
                if (op == "call_ref"sv) {
                  CHECK_ERR(makeCallRef(ctx, pos, annotations, /*isReturn=*/false));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 'o': {
        switch (buf[5]) {
          case 'b':
            if (op == "cont.bind"sv) {
              CHECK_ERR(makeContBind(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'n':
            if (op == "cont.new"sv) {
              CHECK_ERR(makeContNew(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 'd': {
    switch (buf[1]) {
      case 'a':
        if (op == "data.drop"sv) {
          CHECK_ERR(makeDataDrop(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'r':
        if (op == "drop"sv) {
          CHECK_ERR(makeDrop(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'e': {
    switch (buf[1]) {
      case 'l':
        if (op == "elem.drop"sv) {
          CHECK_ERR(makeElemDrop(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'x':
        if (op == "extern.convert_any"sv) {
          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'f': {
    switch (buf[1]) {
      case '1': {
        switch (buf[6]) {
          case 'a': {
            switch (buf[7]) {
              case 'b':
                if (op == "f16x8.abs"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'd':
                if (op == "f16x8.add"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'c': {
            switch (buf[7]) {
              case 'e':
                if (op == "f16x8.ceil"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'o': {
                switch (buf[20]) {
                  case 's':
                    if (op == "f16x8.convert_i16x8_s"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSVecI16x8ToVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f16x8.convert_i16x8_u"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUVecI16x8ToVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'd': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[14]) {
                  case '3':
                    if (op == "f16x8.demote_f32x4_zero"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteZeroVecF32x4ToVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case '6':
                    if (op == "f16x8.demote_f64x2_zero"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteZeroVecF64x2ToVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'i':
                if (op == "f16x8.div"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'e': {
            switch (buf[7]) {
              case 'q':
                if (op == "f16x8.eq"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'x':
                if (op == "f16x8.extract_lane"sv) {
                  CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF16x8, 8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'f':
            if (op == "f16x8.floor"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF16x8));
              return Ok{};
            }
            goto parse_error;
          case 'g': {
            switch (buf[7]) {
              case 'e':
                if (op == "f16x8.ge"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 't':
                if (op == "f16x8.gt"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'l': {
            switch (buf[7]) {
              case 'e':
                if (op == "f16x8.le"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 't':
                if (op == "f16x8.lt"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'm': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[8]) {
                  case 'd':
                    if (op == "f16x8.madd"sv) {
                      CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::MaddVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x':
                    if (op == "f16x8.max"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'i':
                if (op == "f16x8.min"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'u':
                if (op == "f16x8.mul"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'n': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "f16x8.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'a':
                    if (op == "f16x8.nearest"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "f16x8.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm':
                if (op == "f16x8.nmadd"sv) {
                  CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::NmaddVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'p': {
            switch (buf[8]) {
              case 'a':
                if (op == "f16x8.pmax"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'i':
                if (op == "f16x8.pmin"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'r':
            if (op == "f16x8.replace_lane"sv) {
              CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF16x8, 8));
              return Ok{};
            }
            goto parse_error;
          case 's': {
            switch (buf[7]) {
              case 'p':
                if (op == "f16x8.splat"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'q':
                if (op == "f16x8.sqrt"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'u':
                if (op == "f16x8.sub"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 't':
            if (op == "f16x8.trunc"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF16x8));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case '3': {
        switch (buf[3]) {
          case '.': {
            switch (buf[4]) {
              case 'a': {
                switch (buf[5]) {
                  case 'b':
                    if (op == "f32.abs"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "f32.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'c': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f32.ceil"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o': {
                    switch (buf[6]) {
                      case 'n': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "f32.const"sv) {
                              CHECK_ERR(makeConst(ctx, pos, annotations, Type::f32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'v': {
                            switch (buf[13]) {
                              case '3': {
                                switch (buf[16]) {
                                  case 's':
                                    if (op == "f32.convert_i32_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt32ToFloat32));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "f32.convert_i32_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt32ToFloat32));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case '6': {
                                switch (buf[16]) {
                                  case 's':
                                    if (op == "f32.convert_i64_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt64ToFloat32));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "f32.convert_i64_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt64ToFloat32));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'p':
                        if (op == "f32.copysign"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::CopySignFloat32));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'd': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f32.demote_f64"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f32.div"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'e':
                if (op == "f32.eq"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqFloat32));
                  return Ok{};
                }
                goto parse_error;
              case 'f':
                if (op == "f32.floor"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorFloat32));
                  return Ok{};
                }
                goto parse_error;
              case 'g': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f32.ge"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f32.gt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f32.le"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o': {
                    switch (buf[8]) {
                      case '\0':
                        if (op == "f32.load"sv) {
                          CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f32, /*signed=*/false, 4, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '_':
                        if (op == "f32.load_f16"sv) {
                          CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f32, /*signed=*/false, 2, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 't':
                    if (op == "f32.lt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm': {
                switch (buf[5]) {
                  case 'a':
                    if (op == "f32.max"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f32.min"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f32.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[6]) {
                  case '\0':
                    if (op == "f32.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'a':
                    if (op == "f32.nearest"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "f32.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'r':
                if (op == "f32.reinterpret_i32"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretInt32));
                  return Ok{};
                }
                goto parse_error;
              case 's': {
                switch (buf[5]) {
                  case 'q':
                    if (op == "f32.sqrt"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't': {
                    switch (buf[9]) {
                      case '\0':
                        if (op == "f32.store"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::f32, 4, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '_':
                        if (op == "f32.store_f16"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::f32, 2, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'u':
                    if (op == "f32.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubFloat32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't':
                if (op == "f32.trunc"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncFloat32));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'x': {
            switch (buf[6]) {
              case 'a': {
                switch (buf[7]) {
                  case 'b':
                    if (op == "f32x4.abs"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "f32x4.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'c': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f32x4.ceil"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o': {
                    switch (buf[20]) {
                      case 's':
                        if (op == "f32x4.convert_i32x4_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSVecI32x4ToVecF32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "f32x4.convert_i32x4_u"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUVecI32x4ToVecF32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'd': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f32x4.demote_f64x2_zero"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteZeroVecF64x2ToVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f32x4.div"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'e': {
                switch (buf[7]) {
                  case 'q':
                    if (op == "f32x4.eq"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x':
                    if (op == "f32x4.extract_lane"sv) {
                      CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF32x4, 4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'f':
                if (op == "f32x4.floor"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF32x4));
                  return Ok{};
                }
                goto parse_error;
              case 'g': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f32x4.ge"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f32x4.gt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f32x4.le"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f32x4.lt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm': {
                switch (buf[7]) {
                  case 'a':
                    if (op == "f32x4.max"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f32x4.min"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f32x4.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "f32x4.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'a':
                    if (op == "f32x4.nearest"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "f32x4.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p': {
                switch (buf[7]) {
                  case 'm': {
                    switch (buf[8]) {
                      case 'a':
                        if (op == "f32x4.pmax"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'i':
                        if (op == "f32x4.pmin"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'r':
                    if (op == "f32x4.promote_low_f16x8"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PromoteLowVecF16x8ToVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'r': {
                switch (buf[8]) {
                  case 'l': {
                    switch (buf[14]) {
                      case 'm': {
                        switch (buf[15]) {
                          case 'a': {
                            switch (buf[16]) {
                              case 'd':
                                if (op == "f32x4.relaxed_madd"sv) {
                                  CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedMaddVecF32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x':
                                if (op == "f32x4.relaxed_max"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMaxVecF32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'i':
                            if (op == "f32x4.relaxed_min"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMinVecF32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'n':
                        if (op == "f32x4.relaxed_nmadd"sv) {
                          CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedNmaddVecF32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'p':
                    if (op == "f32x4.replace_lane"sv) {
                      CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF32x4, 4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 's': {
                switch (buf[7]) {
                  case 'p':
                    if (op == "f32x4.splat"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'q':
                    if (op == "f32x4.sqrt"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f32x4.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't':
                if (op == "f32x4.trunc"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF32x4));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case '6': {
        switch (buf[3]) {
          case '.': {
            switch (buf[4]) {
              case 'a': {
                switch (buf[5]) {
                  case 'b':
                    if (op == "f64.abs"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "f64.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'c': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f64.ceil"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o': {
                    switch (buf[6]) {
                      case 'n': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "f64.const"sv) {
                              CHECK_ERR(makeConst(ctx, pos, annotations, Type::f64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'v': {
                            switch (buf[13]) {
                              case '3': {
                                switch (buf[16]) {
                                  case 's':
                                    if (op == "f64.convert_i32_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt32ToFloat64));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "f64.convert_i32_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt32ToFloat64));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case '6': {
                                switch (buf[16]) {
                                  case 's':
                                    if (op == "f64.convert_i64_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt64ToFloat64));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "f64.convert_i64_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt64ToFloat64));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'p':
                        if (op == "f64.copysign"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::CopySignFloat64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'd':
                if (op == "f64.div"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivFloat64));
                  return Ok{};
                }
                goto parse_error;
              case 'e':
                if (op == "f64.eq"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqFloat64));
                  return Ok{};
                }
                goto parse_error;
              case 'f':
                if (op == "f64.floor"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorFloat64));
                  return Ok{};
                }
                goto parse_error;
              case 'g': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f64.ge"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f64.gt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[5]) {
                  case 'e':
                    if (op == "f64.le"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o':
                    if (op == "f64.load"sv) {
                      CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f64, /*signed=*/false, 8, /*isAtomic=*/false));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f64.lt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm': {
                switch (buf[5]) {
                  case 'a':
                    if (op == "f64.max"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f64.min"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f64.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[6]) {
                  case '\0':
                    if (op == "f64.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'a':
                    if (op == "f64.nearest"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "f64.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p':
                if (op == "f64.promote_f32"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PromoteFloat32));
                  return Ok{};
                }
                goto parse_error;
              case 'r':
                if (op == "f64.reinterpret_i64"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretInt64));
                  return Ok{};
                }
                goto parse_error;
              case 's': {
                switch (buf[5]) {
                  case 'q':
                    if (op == "f64.sqrt"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f64.store"sv) {
                      CHECK_ERR(makeStore(ctx, pos, annotations, Type::f64, 8, /*isAtomic=*/false));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f64.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubFloat64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't':
                if (op == "f64.trunc"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncFloat64));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'x': {
            switch (buf[6]) {
              case 'a': {
                switch (buf[7]) {
                  case 'b':
                    if (op == "f64x2.abs"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "f64x2.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'c': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f64x2.ceil"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o': {
                    switch (buf[24]) {
                      case 's':
                        if (op == "f64x2.convert_low_i32x4_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertLowSVecI32x4ToVecF64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "f64x2.convert_low_i32x4_u"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertLowUVecI32x4ToVecF64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'd':
                if (op == "f64x2.div"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF64x2));
                  return Ok{};
                }
                goto parse_error;
              case 'e': {
                switch (buf[7]) {
                  case 'q':
                    if (op == "f64x2.eq"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x':
                    if (op == "f64x2.extract_lane"sv) {
                      CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF64x2, 2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'f':
                if (op == "f64x2.floor"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF64x2));
                  return Ok{};
                }
                goto parse_error;
              case 'g': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f64x2.ge"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f64x2.gt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "f64x2.le"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "f64x2.lt"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm': {
                switch (buf[7]) {
                  case 'a':
                    if (op == "f64x2.max"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'i':
                    if (op == "f64x2.min"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f64x2.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "f64x2.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'a':
                    if (op == "f64x2.nearest"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "f64x2.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p': {
                switch (buf[7]) {
                  case 'm': {
                    switch (buf[8]) {
                      case 'a':
                        if (op == "f64x2.pmax"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'i':
                        if (op == "f64x2.pmin"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'r':
                    if (op == "f64x2.promote_low_f32x4"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PromoteLowVecF32x4ToVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'r': {
                switch (buf[8]) {
                  case 'l': {
                    switch (buf[14]) {
                      case 'm': {
                        switch (buf[15]) {
                          case 'a': {
                            switch (buf[16]) {
                              case 'd':
                                if (op == "f64x2.relaxed_madd"sv) {
                                  CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedMaddVecF64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x':
                                if (op == "f64x2.relaxed_max"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMaxVecF64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'i':
                            if (op == "f64x2.relaxed_min"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMinVecF64x2));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'n':
                        if (op == "f64x2.relaxed_nmadd"sv) {
                          CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedNmaddVecF64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'p':
                    if (op == "f64x2.replace_lane"sv) {
                      CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF64x2, 2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 's': {
                switch (buf[7]) {
                  case 'p':
                    if (op == "f64x2.splat"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'q':
                    if (op == "f64x2.sqrt"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "f64x2.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't':
                if (op == "f64x2.trunc"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF64x2));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 'g': {
    switch (buf[7]) {
      case 'g':
        if (op == "global.get"sv) {
          CHECK_ERR(makeGlobalGet(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 's':
        if (op == "global.set"sv) {
          CHECK_ERR(makeGlobalSet(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'i': {
    switch (buf[1]) {
      case '1': {
        switch (buf[6]) {
          case 'a': {
            switch (buf[7]) {
              case 'b':
                if (op == "i16x8.abs"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'd': {
                switch (buf[9]) {
                  case '\0':
                    if (op == "i16x8.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[14]) {
                      case 's':
                        if (op == "i16x8.add_sat_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatSVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i16x8.add_sat_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatUVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'l':
                if (op == "i16x8.all_true"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'v':
                if (op == "i16x8.avgr_u"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AvgrUVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'b':
            if (op == "i16x8.bitmask"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI16x8));
              return Ok{};
            }
            goto parse_error;
          case 'e': {
            switch (buf[7]) {
              case 'q':
                if (op == "i16x8.eq"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'x': {
                switch (buf[9]) {
                  case 'a': {
                    switch (buf[28]) {
                      case 's':
                        if (op == "i16x8.extadd_pairwise_i8x16_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseSVecI8x16ToI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i16x8.extadd_pairwise_i8x16_u"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseUVecI8x16ToI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'e': {
                    switch (buf[13]) {
                      case 'h': {
                        switch (buf[24]) {
                          case 's':
                            if (op == "i16x8.extend_high_i8x16_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI8x16ToVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i16x8.extend_high_i8x16_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI8x16ToVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'l': {
                        switch (buf[23]) {
                          case 's':
                            if (op == "i16x8.extend_low_i8x16_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI8x16ToVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i16x8.extend_low_i8x16_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI8x16ToVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'm': {
                    switch (buf[13]) {
                      case 'h': {
                        switch (buf[24]) {
                          case 's':
                            if (op == "i16x8.extmul_high_i8x16_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i16x8.extmul_high_i8x16_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'l': {
                        switch (buf[23]) {
                          case 's':
                            if (op == "i16x8.extmul_low_i8x16_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i16x8.extmul_low_i8x16_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI16x8));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'r': {
                    switch (buf[19]) {
                      case 's':
                        if (op == "i16x8.extract_lane_s"sv) {
                          CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneSVecI16x8, 8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i16x8.extract_lane_u"sv) {
                          CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneUVecI16x8, 8));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'g': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i16x8.ge_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.ge_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i16x8.gt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.gt_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'l': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i16x8.le_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.le_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i16x8.lt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.lt_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'm': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[10]) {
                  case 's':
                    if (op == "i16x8.max_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.max_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'i': {
                switch (buf[10]) {
                  case 's':
                    if (op == "i16x8.min_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.min_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'u':
                if (op == "i16x8.mul"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'n': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[19]) {
                  case 's':
                    if (op == "i16x8.narrow_i32x4_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowSVecI32x4ToVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i16x8.narrow_i32x4_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowUVecI32x4ToVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'e': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "i16x8.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "i16x8.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'q':
            if (op == "i16x8.q15mulr_sat_s"sv) {
              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::Q15MulrSatSVecI16x8));
              return Ok{};
            }
            goto parse_error;
          case 'r': {
            switch (buf[8]) {
              case 'l': {
                switch (buf[14]) {
                  case 'd':
                    if (op == "i16x8.relaxed_dot_i8x16_i7x16_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedDotI8x16I7x16SToVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'l':
                    if (op == "i16x8.relaxed_laneselect"sv) {
                      CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedLaneselectI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'q':
                    if (op == "i16x8.relaxed_q15mulr_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedQ15MulrSVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p':
                if (op == "i16x8.replace_lane"sv) {
                  CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI16x8, 8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 's': {
            switch (buf[7]) {
              case 'h': {
                switch (buf[8]) {
                  case 'l':
                    if (op == "i16x8.shl"sv) {
                      CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'r': {
                    switch (buf[10]) {
                      case 's':
                        if (op == "i16x8.shr_s"sv) {
                          CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i16x8.shr_u"sv) {
                          CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'p':
                if (op == "i16x8.splat"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'u': {
                switch (buf[9]) {
                  case '\0':
                    if (op == "i16x8.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI16x8));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[14]) {
                      case 's':
                        if (op == "i16x8.sub_sat_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatSVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i16x8.sub_sat_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatUVecI16x8));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 't': {
            switch (buf[22]) {
              case 's':
                if (op == "i16x8.trunc_sat_f16x8_s"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSVecF16x8ToVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              case 'u':
                if (op == "i16x8.trunc_sat_f16x8_u"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUVecF16x8ToVecI16x8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case '3': {
        switch (buf[2]) {
          case '1': {
            switch (buf[8]) {
              case 's':
                if (op == "i31.get_s"sv) {
                  CHECK_ERR(makeI31Get(ctx, pos, annotations, true));
                  return Ok{};
                }
                goto parse_error;
              case 'u':
                if (op == "i31.get_u"sv) {
                  CHECK_ERR(makeI31Get(ctx, pos, annotations, false));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case '2': {
            switch (buf[3]) {
              case '.': {
                switch (buf[4]) {
                  case 'a': {
                    switch (buf[5]) {
                      case 'd':
                        if (op == "i32.add"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'n':
                        if (op == "i32.and"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      case 't': {
                        switch (buf[11]) {
                          case 'l': {
                            switch (buf[15]) {
                              case '\0':
                                if (op == "i32.atomic.load"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 4, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              case '1':
                                if (op == "i32.atomic.load16_u"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 2, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              case '8':
                                if (op == "i32.atomic.load8_u"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 1, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'r': {
                            switch (buf[14]) {
                              case '.': {
                                switch (buf[15]) {
                                  case 'a': {
                                    switch (buf[16]) {
                                      case 'd':
                                        if (op == "i32.atomic.rmw.add"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 4));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'n':
                                        if (op == "i32.atomic.rmw.and"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 4));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  case 'c':
                                    if (op == "i32.atomic.rmw.cmpxchg"sv) {
                                      CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i32.atomic.rmw.or"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 's':
                                    if (op == "i32.atomic.rmw.sub"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'x': {
                                    switch (buf[16]) {
                                      case 'c':
                                        if (op == "i32.atomic.rmw.xchg"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 4));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'o':
                                        if (op == "i32.atomic.rmw.xor"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 4));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  default: goto parse_error;
                                }
                              }
                              case '1': {
                                switch (buf[17]) {
                                  case 'a': {
                                    switch (buf[18]) {
                                      case 'd':
                                        if (op == "i32.atomic.rmw16.add_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 2));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'n':
                                        if (op == "i32.atomic.rmw16.and_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 2));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  case 'c':
                                    if (op == "i32.atomic.rmw16.cmpxchg_u"sv) {
                                      CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i32.atomic.rmw16.or_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 's':
                                    if (op == "i32.atomic.rmw16.sub_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'x': {
                                    switch (buf[18]) {
                                      case 'c':
                                        if (op == "i32.atomic.rmw16.xchg_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 2));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'o':
                                        if (op == "i32.atomic.rmw16.xor_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 2));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  default: goto parse_error;
                                }
                              }
                              case '8': {
                                switch (buf[16]) {
                                  case 'a': {
                                    switch (buf[17]) {
                                      case 'd':
                                        if (op == "i32.atomic.rmw8.add_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 1));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'n':
                                        if (op == "i32.atomic.rmw8.and_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 1));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  case 'c':
                                    if (op == "i32.atomic.rmw8.cmpxchg_u"sv) {
                                      CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i32.atomic.rmw8.or_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 's':
                                    if (op == "i32.atomic.rmw8.sub_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'x': {
                                    switch (buf[17]) {
                                      case 'c':
                                        if (op == "i32.atomic.rmw8.xchg_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 1));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      case 'o':
                                        if (op == "i32.atomic.rmw8.xor_u"sv) {
                                          CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 1));
                                          return Ok{};
                                        }
                                        goto parse_error;
                                      default: goto parse_error;
                                    }
                                  }
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case 's': {
                            switch (buf[16]) {
                              case '\0':
                                if (op == "i32.atomic.store"sv) {
                                  CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 4, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              case '1':
                                if (op == "i32.atomic.store16"sv) {
                                  CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 2, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              case '8':
                                if (op == "i32.atomic.store8"sv) {
                                  CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 1, /*isAtomic=*/true));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'c': {
                    switch (buf[5]) {
                      case 'l':
                        if (op == "i32.clz"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ClzInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'o':
                        if (op == "i32.const"sv) {
                          CHECK_ERR(makeConst(ctx, pos, annotations, Type::i32));
                          return Ok{};
                        }
                        goto parse_error;
                      case 't':
                        if (op == "i32.ctz"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CtzInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'd': {
                    switch (buf[8]) {
                      case 's':
                        if (op == "i32.div_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivSInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i32.div_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivUInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'e': {
                    switch (buf[5]) {
                      case 'q': {
                        switch (buf[6]) {
                          case '\0':
                            if (op == "i32.eq"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'z':
                            if (op == "i32.eqz"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::EqZInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'x': {
                        switch (buf[10]) {
                          case '1':
                            if (op == "i32.extend16_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS16Int32));
                              return Ok{};
                            }
                            goto parse_error;
                          case '8':
                            if (op == "i32.extend8_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS8Int32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'g': {
                    switch (buf[5]) {
                      case 'e': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "i32.ge_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32.ge_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 't': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "i32.gt_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32.gt_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'l': {
                    switch (buf[5]) {
                      case 'e': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "i32.le_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32.le_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'o': {
                        switch (buf[8]) {
                          case '\0':
                            if (op == "i32.load"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 4, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case '1': {
                            switch (buf[11]) {
                              case 's':
                                if (op == "i32.load16_s"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/true, 2, /*isAtomic=*/false));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.load16_u"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 2, /*isAtomic=*/false));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case '8': {
                            switch (buf[10]) {
                              case 's':
                                if (op == "i32.load8_s"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/true, 1, /*isAtomic=*/false));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.load8_u"sv) {
                                  CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 1, /*isAtomic=*/false));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 't': {
                        switch (buf[7]) {
                          case 's':
                            if (op == "i32.lt_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32.lt_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'm':
                    if (op == "i32.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'n':
                    if (op == "i32.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeInt32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o':
                    if (op == "i32.or"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrInt32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'p':
                    if (op == "i32.popcnt"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntInt32));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'r': {
                    switch (buf[5]) {
                      case 'e': {
                        switch (buf[6]) {
                          case 'i':
                            if (op == "i32.reinterpret_f32"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretFloat32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'm': {
                            switch (buf[8]) {
                              case 's':
                                if (op == "i32.rem_s"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemSInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.rem_u"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemUInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'o': {
                        switch (buf[7]) {
                          case 'l':
                            if (op == "i32.rotl"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotLInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'r':
                            if (op == "i32.rotr"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotRInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 's': {
                    switch (buf[5]) {
                      case 'h': {
                        switch (buf[6]) {
                          case 'l':
                            if (op == "i32.shl"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShlInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'r': {
                            switch (buf[8]) {
                              case 's':
                                if (op == "i32.shr_s"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrSInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.shr_u"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrUInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 't': {
                        switch (buf[9]) {
                          case '\0':
                            if (op == "i32.store"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 4, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case '1':
                            if (op == "i32.store16"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 2, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case '8':
                            if (op == "i32.store8"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 1, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'u':
                        if (op == "i32.sub"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt32));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 't': {
                    switch (buf[10]) {
                      case 'f': {
                        switch (buf[11]) {
                          case '3': {
                            switch (buf[14]) {
                              case 's':
                                if (op == "i32.trunc_f32_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat32ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.trunc_f32_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat32ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case '6': {
                            switch (buf[14]) {
                              case 's':
                                if (op == "i32.trunc_f64_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat64ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.trunc_f64_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat64ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 's': {
                        switch (buf[15]) {
                          case '3': {
                            switch (buf[18]) {
                              case 's':
                                if (op == "i32.trunc_sat_f32_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat32ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.trunc_sat_f32_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat32ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case '6': {
                            switch (buf[18]) {
                              case 's':
                                if (op == "i32.trunc_sat_f64_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat64ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32.trunc_sat_f64_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat64ToInt32));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'w':
                    if (op == "i32.wrap_i64"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::WrapInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x':
                    if (op == "i32.xor"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorInt32));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'x': {
                switch (buf[6]) {
                  case 'a': {
                    switch (buf[7]) {
                      case 'b':
                        if (op == "i32x4.abs"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'd':
                        if (op == "i32x4.add"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'l':
                        if (op == "i32x4.all_true"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'b':
                    if (op == "i32x4.bitmask"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "i32x4.dot_i16x8_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DotSVecI16x8ToVecI32x4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'e': {
                    switch (buf[7]) {
                      case 'q':
                        if (op == "i32x4.eq"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'x': {
                        switch (buf[9]) {
                          case 'a': {
                            switch (buf[28]) {
                              case 's':
                                if (op == "i32x4.extadd_pairwise_i16x8_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseSVecI16x8ToI32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32x4.extadd_pairwise_i16x8_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseUVecI16x8ToI32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'e': {
                            switch (buf[13]) {
                              case 'h': {
                                switch (buf[24]) {
                                  case 's':
                                    if (op == "i32x4.extend_high_i16x8_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI16x8ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.extend_high_i16x8_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI16x8ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'l': {
                                switch (buf[23]) {
                                  case 's':
                                    if (op == "i32x4.extend_low_i16x8_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI16x8ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.extend_low_i16x8_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI16x8ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case 'm': {
                            switch (buf[13]) {
                              case 'h': {
                                switch (buf[24]) {
                                  case 's':
                                    if (op == "i32x4.extmul_high_i16x8_s"sv) {
                                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.extmul_high_i16x8_u"sv) {
                                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'l': {
                                switch (buf[23]) {
                                  case 's':
                                    if (op == "i32x4.extmul_low_i16x8_s"sv) {
                                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.extmul_low_i16x8_u"sv) {
                                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case 'r':
                            if (op == "i32x4.extract_lane"sv) {
                              CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecI32x4, 4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'g': {
                    switch (buf[7]) {
                      case 'e': {
                        switch (buf[9]) {
                          case 's':
                            if (op == "i32x4.ge_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.ge_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 't': {
                        switch (buf[9]) {
                          case 's':
                            if (op == "i32x4.gt_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.gt_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'l': {
                    switch (buf[7]) {
                      case 'e': {
                        switch (buf[9]) {
                          case 's':
                            if (op == "i32x4.le_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.le_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 't': {
                        switch (buf[9]) {
                          case 's':
                            if (op == "i32x4.lt_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.lt_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'm': {
                    switch (buf[7]) {
                      case 'a': {
                        switch (buf[10]) {
                          case 's':
                            if (op == "i32x4.max_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.max_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'i': {
                        switch (buf[10]) {
                          case 's':
                            if (op == "i32x4.min_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.min_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'u':
                        if (op == "i32x4.mul"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'n': {
                    switch (buf[8]) {
                      case '\0':
                        if (op == "i32x4.ne"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'g':
                        if (op == "i32x4.neg"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'r': {
                    switch (buf[8]) {
                      case 'l': {
                        switch (buf[14]) {
                          case 'd':
                            if (op == "i32x4.relaxed_dot_i8x16_i7x16_add_s"sv) {
                              CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedDotI8x16I7x16AddSToVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'l':
                            if (op == "i32x4.relaxed_laneselect"sv) {
                              CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedLaneselectI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 't': {
                            switch (buf[21]) {
                              case '3': {
                                switch (buf[26]) {
                                  case 's':
                                    if (op == "i32x4.relaxed_trunc_f32x4_s"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncSVecF32x4ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.relaxed_trunc_f32x4_u"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncUVecF32x4ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case '6': {
                                switch (buf[26]) {
                                  case 's':
                                    if (op == "i32x4.relaxed_trunc_f64x2_s_zero"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncZeroSVecF64x2ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'u':
                                    if (op == "i32x4.relaxed_trunc_f64x2_u_zero"sv) {
                                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncZeroUVecF64x2ToVecI32x4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'p':
                        if (op == "i32x4.replace_lane"sv) {
                          CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI32x4, 4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 's': {
                    switch (buf[7]) {
                      case 'h': {
                        switch (buf[8]) {
                          case 'l':
                            if (op == "i32x4.shl"sv) {
                              CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'r': {
                            switch (buf[10]) {
                              case 's':
                                if (op == "i32x4.shr_s"sv) {
                                  CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i32x4.shr_u"sv) {
                                  CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI32x4));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'p':
                        if (op == "i32x4.splat"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i32x4.sub"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI32x4));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 't': {
                    switch (buf[17]) {
                      case '3': {
                        switch (buf[22]) {
                          case 's':
                            if (op == "i32x4.trunc_sat_f32x4_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSVecF32x4ToVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.trunc_sat_f32x4_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUVecF32x4ToVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case '6': {
                        switch (buf[22]) {
                          case 's':
                            if (op == "i32x4.trunc_sat_f64x2_s_zero"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatZeroSVecF64x2ToVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i32x4.trunc_sat_f64x2_u_zero"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatZeroUVecF64x2ToVecI32x4));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case '6': {
        switch (buf[3]) {
          case '.': {
            switch (buf[4]) {
              case 'a': {
                switch (buf[5]) {
                  case 'd': {
                    switch (buf[7]) {
                      case '\0':
                        if (op == "i64.add"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case '1':
                        if (op == "i64.add128"sv) {
                          CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::AddInt128));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'n':
                    if (op == "i64.and"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't': {
                    switch (buf[11]) {
                      case 'l': {
                        switch (buf[15]) {
                          case '\0':
                            if (op == "i64.atomic.load"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 8, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '1':
                            if (op == "i64.atomic.load16_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 2, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '3':
                            if (op == "i64.atomic.load32_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 4, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '8':
                            if (op == "i64.atomic.load8_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 1, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'r': {
                        switch (buf[14]) {
                          case '.': {
                            switch (buf[15]) {
                              case 'a': {
                                switch (buf[16]) {
                                  case 'd':
                                    if (op == "i64.atomic.rmw.add"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 8));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'n':
                                    if (op == "i64.atomic.rmw.and"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 8));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'c':
                                if (op == "i64.atomic.rmw.cmpxchg"sv) {
                                  CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 8));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'o':
                                if (op == "i64.atomic.rmw.or"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 8));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 's':
                                if (op == "i64.atomic.rmw.sub"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 8));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x': {
                                switch (buf[16]) {
                                  case 'c':
                                    if (op == "i64.atomic.rmw.xchg"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 8));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i64.atomic.rmw.xor"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 8));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case '1': {
                            switch (buf[17]) {
                              case 'a': {
                                switch (buf[18]) {
                                  case 'd':
                                    if (op == "i64.atomic.rmw16.add_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'n':
                                    if (op == "i64.atomic.rmw16.and_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'c':
                                if (op == "i64.atomic.rmw16.cmpxchg_u"sv) {
                                  CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'o':
                                if (op == "i64.atomic.rmw16.or_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 's':
                                if (op == "i64.atomic.rmw16.sub_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x': {
                                switch (buf[18]) {
                                  case 'c':
                                    if (op == "i64.atomic.rmw16.xchg_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i64.atomic.rmw16.xor_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 2));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case '3': {
                            switch (buf[17]) {
                              case 'a': {
                                switch (buf[18]) {
                                  case 'd':
                                    if (op == "i64.atomic.rmw32.add_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'n':
                                    if (op == "i64.atomic.rmw32.and_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'c':
                                if (op == "i64.atomic.rmw32.cmpxchg_u"sv) {
                                  CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'o':
                                if (op == "i64.atomic.rmw32.or_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 's':
                                if (op == "i64.atomic.rmw32.sub_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 4));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x': {
                                switch (buf[18]) {
                                  case 'c':
                                    if (op == "i64.atomic.rmw32.xchg_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i64.atomic.rmw32.xor_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 4));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          case '8': {
                            switch (buf[16]) {
                              case 'a': {
                                switch (buf[17]) {
                                  case 'd':
                                    if (op == "i64.atomic.rmw8.add_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'n':
                                    if (op == "i64.atomic.rmw8.and_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              case 'c':
                                if (op == "i64.atomic.rmw8.cmpxchg_u"sv) {
                                  CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 1));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'o':
                                if (op == "i64.atomic.rmw8.or_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 1));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 's':
                                if (op == "i64.atomic.rmw8.sub_u"sv) {
                                  CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 1));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'x': {
                                switch (buf[17]) {
                                  case 'c':
                                    if (op == "i64.atomic.rmw8.xchg_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  case 'o':
                                    if (op == "i64.atomic.rmw8.xor_u"sv) {
                                      CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 1));
                                      return Ok{};
                                    }
                                    goto parse_error;
                                  default: goto parse_error;
                                }
                              }
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 's': {
                        switch (buf[16]) {
                          case '\0':
                            if (op == "i64.atomic.store"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 8, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '1':
                            if (op == "i64.atomic.store16"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 2, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '3':
                            if (op == "i64.atomic.store32"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 4, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          case '8':
                            if (op == "i64.atomic.store8"sv) {
                              CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 1, /*isAtomic=*/true));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'c': {
                switch (buf[5]) {
                  case 'l':
                    if (op == "i64.clz"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ClzInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'o':
                    if (op == "i64.const"sv) {
                      CHECK_ERR(makeConst(ctx, pos, annotations, Type::i64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "i64.ctz"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CtzInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'd': {
                switch (buf[8]) {
                  case 's':
                    if (op == "i64.div_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivSInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i64.div_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivUInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'e': {
                switch (buf[5]) {
                  case 'q': {
                    switch (buf[6]) {
                      case '\0':
                        if (op == "i64.eq"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'z':
                        if (op == "i64.eqz"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::EqZInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'x': {
                    switch (buf[10]) {
                      case '1':
                        if (op == "i64.extend16_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS16Int64));
                          return Ok{};
                        }
                        goto parse_error;
                      case '3':
                        if (op == "i64.extend32_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS32Int64));
                          return Ok{};
                        }
                        goto parse_error;
                      case '8':
                        if (op == "i64.extend8_s"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS8Int64));
                          return Ok{};
                        }
                        goto parse_error;
                      case '_': {
                        switch (buf[15]) {
                          case 's':
                            if (op == "i64.extend_i32_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendSInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.extend_i32_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendUInt32));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'g': {
                switch (buf[5]) {
                  case 'e': {
                    switch (buf[7]) {
                      case 's':
                        if (op == "i64.ge_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i64.ge_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 't': {
                    switch (buf[7]) {
                      case 's':
                        if (op == "i64.gt_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i64.gt_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[5]) {
                  case 'e': {
                    switch (buf[7]) {
                      case 's':
                        if (op == "i64.le_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i64.le_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'o': {
                    switch (buf[8]) {
                      case '\0':
                        if (op == "i64.load"sv) {
                          CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 8, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '1': {
                        switch (buf[11]) {
                          case 's':
                            if (op == "i64.load16_s"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 2, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.load16_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 2, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case '3': {
                        switch (buf[11]) {
                          case 's':
                            if (op == "i64.load32_s"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 4, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.load32_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 4, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case '8': {
                        switch (buf[10]) {
                          case 's':
                            if (op == "i64.load8_s"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 1, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.load8_u"sv) {
                              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 1, /*isAtomic=*/false));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 't': {
                    switch (buf[7]) {
                      case 's':
                        if (op == "i64.lt_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i64.lt_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'm': {
                switch (buf[7]) {
                  case '\0':
                    if (op == "i64.mul"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt64));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[13]) {
                      case 's':
                        if (op == "i64.mul_wide_s"sv) {
                          CHECK_ERR(makeWideIntMul(ctx, pos, annotations, WideIntMulOp::MulWideSInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i64.mul_wide_u"sv) {
                          CHECK_ERR(makeWideIntMul(ctx, pos, annotations, WideIntMulOp::MulWideUInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'n':
                if (op == "i64.ne"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeInt64));
                  return Ok{};
                }
                goto parse_error;
              case 'o':
                if (op == "i64.or"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrInt64));
                  return Ok{};
                }
                goto parse_error;
              case 'p':
                if (op == "i64.popcnt"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntInt64));
                  return Ok{};
                }
                goto parse_error;
              case 'r': {
                switch (buf[5]) {
                  case 'e': {
                    switch (buf[6]) {
                      case 'i':
                        if (op == "i64.reinterpret_f64"sv) {
                          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretFloat64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'm': {
                        switch (buf[8]) {
                          case 's':
                            if (op == "i64.rem_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemSInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.rem_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemUInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'o': {
                    switch (buf[7]) {
                      case 'l':
                        if (op == "i64.rotl"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotLInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'r':
                        if (op == "i64.rotr"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotRInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 's': {
                switch (buf[5]) {
                  case 'h': {
                    switch (buf[6]) {
                      case 'l':
                        if (op == "i64.shl"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShlInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'r': {
                        switch (buf[8]) {
                          case 's':
                            if (op == "i64.shr_s"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrSInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.shr_u"sv) {
                              CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrUInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 't': {
                    switch (buf[9]) {
                      case '\0':
                        if (op == "i64.store"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 8, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '1':
                        if (op == "i64.store16"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 2, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '3':
                        if (op == "i64.store32"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 4, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      case '8':
                        if (op == "i64.store8"sv) {
                          CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 1, /*isAtomic=*/false));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'u': {
                    switch (buf[7]) {
                      case '\0':
                        if (op == "i64.sub"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt64));
                          return Ok{};
                        }
                        goto parse_error;
                      case '1':
                        if (op == "i64.sub128"sv) {
                          CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::SubInt128));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 't': {
                switch (buf[10]) {
                  case 'f': {
                    switch (buf[11]) {
                      case '3': {
                        switch (buf[14]) {
                          case 's':
                            if (op == "i64.trunc_f32_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat32ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.trunc_f32_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat32ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case '6': {
                        switch (buf[14]) {
                          case 's':
                            if (op == "i64.trunc_f64_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat64ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.trunc_f64_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat64ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 's': {
                    switch (buf[15]) {
                      case '3': {
                        switch (buf[18]) {
                          case 's':
                            if (op == "i64.trunc_sat_f32_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat32ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.trunc_sat_f32_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat32ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case '6': {
                        switch (buf[18]) {
                          case 's':
                            if (op == "i64.trunc_sat_f64_s"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat64ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64.trunc_sat_f64_u"sv) {
                              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat64ToInt64));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'x':
                if (op == "i64.xor"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorInt64));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'x': {
            switch (buf[6]) {
              case 'a': {
                switch (buf[7]) {
                  case 'b':
                    if (op == "i64x2.abs"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'd':
                    if (op == "i64x2.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'l':
                    if (op == "i64x2.all_true"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'b':
                if (op == "i64x2.bitmask"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI64x2));
                  return Ok{};
                }
                goto parse_error;
              case 'e': {
                switch (buf[7]) {
                  case 'q':
                    if (op == "i64x2.eq"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'x': {
                    switch (buf[9]) {
                      case 'e': {
                        switch (buf[13]) {
                          case 'h': {
                            switch (buf[24]) {
                              case 's':
                                if (op == "i64x2.extend_high_i32x4_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI32x4ToVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i64x2.extend_high_i32x4_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI32x4ToVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'l': {
                            switch (buf[23]) {
                              case 's':
                                if (op == "i64x2.extend_low_i32x4_s"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI32x4ToVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i64x2.extend_low_i32x4_u"sv) {
                                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI32x4ToVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'm': {
                        switch (buf[13]) {
                          case 'h': {
                            switch (buf[24]) {
                              case 's':
                                if (op == "i64x2.extmul_high_i32x4_s"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i64x2.extmul_high_i32x4_u"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          case 'l': {
                            switch (buf[23]) {
                              case 's':
                                if (op == "i64x2.extmul_low_i32x4_s"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              case 'u':
                                if (op == "i64x2.extmul_low_i32x4_u"sv) {
                                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI64x2));
                                  return Ok{};
                                }
                                goto parse_error;
                              default: goto parse_error;
                            }
                          }
                          default: goto parse_error;
                        }
                      }
                      case 'r':
                        if (op == "i64x2.extract_lane"sv) {
                          CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecI64x2, 2));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'g': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "i64x2.ge_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "i64x2.gt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'l': {
                switch (buf[7]) {
                  case 'e':
                    if (op == "i64x2.le_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 't':
                    if (op == "i64x2.lt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'm':
                if (op == "i64x2.mul"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI64x2));
                  return Ok{};
                }
                goto parse_error;
              case 'n': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "i64x2.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "i64x2.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'r': {
                switch (buf[8]) {
                  case 'l':
                    if (op == "i64x2.relaxed_laneselect"sv) {
                      CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedLaneselectI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'p':
                    if (op == "i64x2.replace_lane"sv) {
                      CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI64x2, 2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 's': {
                switch (buf[7]) {
                  case 'h': {
                    switch (buf[8]) {
                      case 'l':
                        if (op == "i64x2.shl"sv) {
                          CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI64x2));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'r': {
                        switch (buf[10]) {
                          case 's':
                            if (op == "i64x2.shr_s"sv) {
                              CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI64x2));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "i64x2.shr_u"sv) {
                              CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI64x2));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'p':
                    if (op == "i64x2.splat"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i64x2.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI64x2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case '8': {
        switch (buf[6]) {
          case 'a': {
            switch (buf[7]) {
              case 'b':
                if (op == "i8x16.abs"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              case 'd': {
                switch (buf[9]) {
                  case '\0':
                    if (op == "i8x16.add"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[14]) {
                      case 's':
                        if (op == "i8x16.add_sat_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatSVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i8x16.add_sat_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatUVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'l':
                if (op == "i8x16.all_true"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              case 'v':
                if (op == "i8x16.avgr_u"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AvgrUVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'b':
            if (op == "i8x16.bitmask"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI8x16));
              return Ok{};
            }
            goto parse_error;
          case 'e': {
            switch (buf[7]) {
              case 'q':
                if (op == "i8x16.eq"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              case 'x': {
                switch (buf[19]) {
                  case 's':
                    if (op == "i8x16.extract_lane_s"sv) {
                      CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneSVecI8x16, 16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.extract_lane_u"sv) {
                      CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneUVecI8x16, 16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'g': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i8x16.ge_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.ge_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i8x16.gt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.gt_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'l': {
            switch (buf[7]) {
              case 'e': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i8x16.le_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.le_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 't': {
                switch (buf[9]) {
                  case 's':
                    if (op == "i8x16.lt_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.lt_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'm': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[10]) {
                  case 's':
                    if (op == "i8x16.max_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.max_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'i': {
                switch (buf[10]) {
                  case 's':
                    if (op == "i8x16.min_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.min_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'n': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[19]) {
                  case 's':
                    if (op == "i8x16.narrow_i16x8_s"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowSVecI16x8ToVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "i8x16.narrow_i16x8_u"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowUVecI16x8ToVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'e': {
                switch (buf[8]) {
                  case '\0':
                    if (op == "i8x16.ne"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'g':
                    if (op == "i8x16.neg"sv) {
                      CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'p':
            if (op == "i8x16.popcnt"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntVecI8x16));
              return Ok{};
            }
            goto parse_error;
          case 'r': {
            switch (buf[8]) {
              case 'l': {
                switch (buf[14]) {
                  case 'l':
                    if (op == "i8x16.relaxed_laneselect"sv) {
                      CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedLaneselectI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "i8x16.relaxed_swizzle"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedSwizzleVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p':
                if (op == "i8x16.replace_lane"sv) {
                  CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI8x16, 16));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 's': {
            switch (buf[7]) {
              case 'h': {
                switch (buf[8]) {
                  case 'l':
                    if (op == "i8x16.shl"sv) {
                      CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'r': {
                    switch (buf[10]) {
                      case 's':
                        if (op == "i8x16.shr_s"sv) {
                          CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i8x16.shr_u"sv) {
                          CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'u':
                    if (op == "i8x16.shuffle"sv) {
                      CHECK_ERR(makeSIMDShuffle(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'p':
                if (op == "i8x16.splat"sv) {
                  CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              case 'u': {
                switch (buf[9]) {
                  case '\0':
                    if (op == "i8x16.sub"sv) {
                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI8x16));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[14]) {
                      case 's':
                        if (op == "i8x16.sub_sat_s"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatSVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "i8x16.sub_sat_u"sv) {
                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatUVecI8x16));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'w':
                if (op == "i8x16.swizzle"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SwizzleVecI8x16));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 'l': {
    switch (buf[6]) {
      case 'g':
        if (op == "local.get"sv) {
          CHECK_ERR(makeLocalGet(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 's':
        if (op == "local.set"sv) {
          CHECK_ERR(makeLocalSet(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 't':
        if (op == "local.tee"sv) {
          CHECK_ERR(makeLocalTee(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'm': {
    switch (buf[7]) {
      case 'a': {
        switch (buf[14]) {
          case 'n':
            if (op == "memory.atomic.notify"sv) {
              CHECK_ERR(makeAtomicNotify(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'w': {
            switch (buf[18]) {
              case '3':
                if (op == "memory.atomic.wait32"sv) {
                  CHECK_ERR(makeAtomicWait(ctx, pos, annotations, Type::i32));
                  return Ok{};
                }
                goto parse_error;
              case '6':
                if (op == "memory.atomic.wait64"sv) {
                  CHECK_ERR(makeAtomicWait(ctx, pos, annotations, Type::i64));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 'c':
        if (op == "memory.copy"sv) {
          CHECK_ERR(makeMemoryCopy(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'f':
        if (op == "memory.fill"sv) {
          CHECK_ERR(makeMemoryFill(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'g':
        if (op == "memory.grow"sv) {
          CHECK_ERR(makeMemoryGrow(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'i':
        if (op == "memory.init"sv) {
          CHECK_ERR(makeMemoryInit(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 's':
        if (op == "memory.size"sv) {
          CHECK_ERR(makeMemorySize(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'n':
    if (op == "nop"sv) {
      CHECK_ERR(makeNop(ctx, pos, annotations));
      return Ok{};
    }
    goto parse_error;
  case 'p': {
    switch (buf[1]) {
      case 'a':
        if (op == "pause"sv) {
          CHECK_ERR(makePause(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'o':
        if (op == "pop"sv) {
          CHECK_ERR(makePop(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'u':
        if (op == "publish"sv) {
          CHECK_ERR(makePublish(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'r': {
    switch (buf[2]) {
      case 'f': {
        switch (buf[4]) {
          case 'a':
            if (op == "ref.as_non_null"sv) {
              CHECK_ERR(makeRefAs(ctx, pos, annotations, RefAsNonNull));
              return Ok{};
            }
            goto parse_error;
          case 'c': {
            switch (buf[8]) {
              case '\0':
                if (op == "ref.cast"sv) {
                  CHECK_ERR(makeRefCast(ctx, pos, annotations, false));
                  return Ok{};
                }
                goto parse_error;
              case '_':
                if (op == "ref.cast_desc_eq"sv) {
                  CHECK_ERR(makeRefCast(ctx, pos, annotations, true));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'e':
            if (op == "ref.eq"sv) {
              CHECK_ERR(makeRefEq(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'f':
            if (op == "ref.func"sv) {
              CHECK_ERR(makeRefFunc(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'g':
            if (op == "ref.get_desc"sv) {
              CHECK_ERR(makeRefGetDesc(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'i': {
            switch (buf[5]) {
              case '3': {
                switch (buf[7]) {
                  case '\0':
                    if (op == "ref.i31"sv) {
                      CHECK_ERR(makeRefI31(ctx, pos, annotations, Unshared));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_':
                    if (op == "ref.i31_shared"sv) {
                      CHECK_ERR(makeRefI31(ctx, pos, annotations, Shared));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 's':
                if (op == "ref.is_null"sv) {
                  CHECK_ERR(makeRefIsNull(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'n':
            if (op == "ref.null"sv) {
              CHECK_ERR(makeRefNull(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 't':
            if (op == "ref.test"sv) {
              CHECK_ERR(makeRefTest(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case 's': {
        switch (buf[6]) {
          case '\0':
            if (op == "resume"sv) {
              CHECK_ERR(makeResume(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case '_': {
            switch (buf[12]) {
              case '\0':
                if (op == "resume_throw"sv) {
                  CHECK_ERR(makeResumeThrow(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case '_':
                if (op == "resume_throw_ref"sv) {
                  CHECK_ERR(makeResumeThrowRef(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 't': {
        switch (buf[3]) {
          case 'h':
            if (op == "rethrow"sv) {
              CHECK_ERR(makeRethrow(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'u': {
            switch (buf[6]) {
              case '\0':
                if (op == "return"sv) {
                  CHECK_ERR(makeReturn(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case '_': {
                switch (buf[11]) {
                  case '\0':
                    if (op == "return_call"sv) {
                      CHECK_ERR(makeCall(ctx, pos, annotations, /*isReturn=*/true));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[12]) {
                      case 'i':
                        if (op == "return_call_indirect"sv) {
                          CHECK_ERR(makeCallIndirect(ctx, pos, annotations, /*isReturn=*/true));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'r':
                        if (op == "return_call_ref"sv) {
                          CHECK_ERR(makeCallRef(ctx, pos, annotations, /*isReturn=*/true));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 's': {
    switch (buf[1]) {
      case 'e':
        if (op == "select"sv) {
          CHECK_ERR(makeSelect(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 't': {
        switch (buf[3]) {
          case 'i': {
            switch (buf[6]) {
              case '.': {
                switch (buf[7]) {
                  case 'a':
                    if (op == "string.as_wtf16"sv) {
                      CHECK_ERR(ignore(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'c': {
                    switch (buf[9]) {
                      case 'm':
                        if (op == "string.compare"sv) {
                          CHECK_ERR(makeStringEq(ctx, pos, annotations, StringEqCompare));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'n': {
                        switch (buf[10]) {
                          case 'c':
                            if (op == "string.concat"sv) {
                              CHECK_ERR(makeStringConcat(ctx, pos, annotations));
                              return Ok{};
                            }
                            goto parse_error;
                          case 's':
                            if (op == "string.const"sv) {
                              CHECK_ERR(makeStringConst(ctx, pos, annotations));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'e': {
                    switch (buf[8]) {
                      case 'n': {
                        switch (buf[14]) {
                          case 'l':
                            if (op == "string.encode_lossy_utf8_array"sv) {
                              CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeLossyUTF8Array));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'w':
                            if (op == "string.encode_wtf16_array"sv) {
                              CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF16Array));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'q':
                        if (op == "string.eq"sv) {
                          CHECK_ERR(makeStringEq(ctx, pos, annotations, StringEqEqual));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'f':
                    if (op == "string.from_code_point"sv) {
                      CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewFromCodePoint));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'm': {
                    switch (buf[15]) {
                      case 'u':
                        if (op == "string.measure_utf8"sv) {
                          CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureUTF8));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'w':
                        if (op == "string.measure_wtf16"sv) {
                          CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 'n': {
                    switch (buf[11]) {
                      case 'l':
                        if (op == "string.new_lossy_utf8_array"sv) {
                          CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewLossyUTF8Array));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'w':
                        if (op == "string.new_wtf16_array"sv) {
                          CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF16Array));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  case 't':
                    if (op == "string.test"sv) {
                      CHECK_ERR(makeStringTest(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'v': {
                switch (buf[17]) {
                  case 'g':
                    if (op == "stringview_wtf16.get_codeunit"sv) {
                      CHECK_ERR(makeStringWTF16Get(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'l':
                    if (op == "stringview_wtf16.length"sv) {
                      CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "stringview_wtf16.slice"sv) {
                      CHECK_ERR(makeStringSliceWTF(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case 'u': {
            switch (buf[7]) {
              case 'a': {
                switch (buf[14]) {
                  case 'g': {
                    switch (buf[17]) {
                      case '\0':
                        if (op == "struct.atomic.get"sv) {
                          CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations));
                          return Ok{};
                        }
                        goto parse_error;
                      case '_': {
                        switch (buf[18]) {
                          case 's':
                            if (op == "struct.atomic.get_s"sv) {
                              CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations, true));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'u':
                            if (op == "struct.atomic.get_u"sv) {
                              CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations, false));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 'r': {
                    switch (buf[18]) {
                      case 'a': {
                        switch (buf[19]) {
                          case 'd':
                            if (op == "struct.atomic.rmw.add"sv) {
                              CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWAdd));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'n':
                            if (op == "struct.atomic.rmw.and"sv) {
                              CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWAnd));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 'c':
                        if (op == "struct.atomic.rmw.cmpxchg"sv) {
                          CHECK_ERR(makeStructCmpxchg(ctx, pos, annotations));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'o':
                        if (op == "struct.atomic.rmw.or"sv) {
                          CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWOr));
                          return Ok{};
                        }
                        goto parse_error;
                      case 's':
                        if (op == "struct.atomic.rmw.sub"sv) {
                          CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWSub));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'x': {
                        switch (buf[19]) {
                          case 'c':
                            if (op == "struct.atomic.rmw.xchg"sv) {
                              CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWXchg));
                              return Ok{};
                            }
                            goto parse_error;
                          case 'o':
                            if (op == "struct.atomic.rmw.xor"sv) {
                              CHECK_ERR(makeStructRMW(ctx, pos, annotations, RMWXor));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      default: goto parse_error;
                    }
                  }
                  case 's':
                    if (op == "struct.atomic.set"sv) {
                      CHECK_ERR(makeAtomicStructSet(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'g': {
                switch (buf[10]) {
                  case '\0':
                    if (op == "struct.get"sv) {
                      CHECK_ERR(makeStructGet(ctx, pos, annotations));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[11]) {
                      case 's':
                        if (op == "struct.get_s"sv) {
                          CHECK_ERR(makeStructGet(ctx, pos, annotations, true));
                          return Ok{};
                        }
                        goto parse_error;
                      case 'u':
                        if (op == "struct.get_u"sv) {
                          CHECK_ERR(makeStructGet(ctx, pos, annotations, false));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 'n': {
                switch (buf[10]) {
                  case '\0':
                    if (op == "struct.new"sv) {
                      CHECK_ERR(makeStructNew(ctx, pos, annotations, false, false));
                      return Ok{};
                    }
                    goto parse_error;
                  case '_': {
                    switch (buf[13]) {
                      case 'f': {
                        switch (buf[18]) {
                          case '\0':
                            if (op == "struct.new_default"sv) {
                              CHECK_ERR(makeStructNew(ctx, pos, annotations, true, false));
                              return Ok{};
                            }
                            goto parse_error;
                          case '_':
                            if (op == "struct.new_default_desc"sv) {
                              CHECK_ERR(makeStructNew(ctx, pos, annotations, true, true));
                              return Ok{};
                            }
                            goto parse_error;
                          default: goto parse_error;
                        }
                      }
                      case 's':
                        if (op == "struct.new_desc"sv) {
                          CHECK_ERR(makeStructNew(ctx, pos, annotations, false, true));
                          return Ok{};
                        }
                        goto parse_error;
                      default: goto parse_error;
                    }
                  }
                  default: goto parse_error;
                }
              }
              case 's':
                if (op == "struct.set"sv) {
                  CHECK_ERR(makeStructSet(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case 'w':
                if (op == "struct.wait"sv) {
                  CHECK_ERR(makeStructWait(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 'u':
        if (op == "suspend"sv) {
          CHECK_ERR(makeSuspend(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'w':
        if (op == "switch"sv) {
          CHECK_ERR(makeStackSwitch(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 't': {
    switch (buf[1]) {
      case 'a': {
        switch (buf[6]) {
          case 'c':
            if (op == "table.copy"sv) {
              CHECK_ERR(makeTableCopy(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'f':
            if (op == "table.fill"sv) {
              CHECK_ERR(makeTableFill(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'g': {
            switch (buf[7]) {
              case 'e':
                if (op == "table.get"sv) {
                  CHECK_ERR(makeTableGet(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case 'r':
                if (op == "table.grow"sv) {
                  CHECK_ERR(makeTableGrow(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'i':
            if (op == "table.init"sv) {
              CHECK_ERR(makeTableInit(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 's': {
            switch (buf[7]) {
              case 'e':
                if (op == "table.set"sv) {
                  CHECK_ERR(makeTableSet(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              case 'i':
                if (op == "table.size"sv) {
                  CHECK_ERR(makeTableSize(ctx, pos, annotations));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 'h': {
        switch (buf[5]) {
          case '\0':
            if (op == "throw"sv) {
              CHECK_ERR(makeThrow(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case '_':
            if (op == "throw_ref"sv) {
              CHECK_ERR(makeThrowRef(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case 'u': {
        switch (buf[6]) {
          case 'd':
            if (op == "tuple.drop"sv) {
              CHECK_ERR(makeTupleDrop(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'e':
            if (op == "tuple.extract"sv) {
              CHECK_ERR(makeTupleExtract(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          case 'm':
            if (op == "tuple.make"sv) {
              CHECK_ERR(makeTupleMake(ctx, pos, annotations));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      default: goto parse_error;
    }
  }
  case 'u':
    if (op == "unreachable"sv) {
      CHECK_ERR(makeUnreachable(ctx, pos, annotations));
      return Ok{};
    }
    goto parse_error;
  case 'v': {
    switch (buf[5]) {
      case 'a': {
        switch (buf[7]) {
          case 'd': {
            switch (buf[8]) {
              case '\0':
                if (op == "v128.and"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndVec128));
                  return Ok{};
                }
                goto parse_error;
              case 'n':
                if (op == "v128.andnot"sv) {
                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndNotVec128));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case 'y':
            if (op == "v128.any_true"sv) {
              CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AnyTrueVec128));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case 'b':
        if (op == "v128.bitselect"sv) {
          CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::Bitselect));
          return Ok{};
        }
        goto parse_error;
      case 'c':
        if (op == "v128.const"sv) {
          CHECK_ERR(makeConst(ctx, pos, annotations, Type::v128));
          return Ok{};
        }
        goto parse_error;
      case 'l': {
        switch (buf[9]) {
          case '\0':
            if (op == "v128.load"sv) {
              CHECK_ERR(makeLoad(ctx, pos, annotations, Type::v128, /*signed=*/false, 16, /*isAtomic=*/false));
              return Ok{};
            }
            goto parse_error;
          case '1': {
            switch (buf[11]) {
              case '_': {
                switch (buf[12]) {
                  case 'l':
                    if (op == "v128.load16_lane"sv) {
                      CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load16LaneVec128, 2));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "v128.load16_splat"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16SplatVec128, 2));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'x': {
                switch (buf[14]) {
                  case 's':
                    if (op == "v128.load16x4_s"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16x4SVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "v128.load16x4_u"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16x4UVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case '3': {
            switch (buf[11]) {
              case '_': {
                switch (buf[12]) {
                  case 'l':
                    if (op == "v128.load32_lane"sv) {
                      CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load32LaneVec128, 4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "v128.load32_splat"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32SplatVec128, 4));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'z':
                    if (op == "v128.load32_zero"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32ZeroVec128, 4));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'x': {
                switch (buf[14]) {
                  case 's':
                    if (op == "v128.load32x2_s"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32x2SVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "v128.load32x2_u"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32x2UVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          case '6': {
            switch (buf[12]) {
              case 'l':
                if (op == "v128.load64_lane"sv) {
                  CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load64LaneVec128, 8));
                  return Ok{};
                }
                goto parse_error;
              case 's':
                if (op == "v128.load64_splat"sv) {
                  CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load64SplatVec128, 8));
                  return Ok{};
                }
                goto parse_error;
              case 'z':
                if (op == "v128.load64_zero"sv) {
                  CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load64ZeroVec128, 8));
                  return Ok{};
                }
                goto parse_error;
              default: goto parse_error;
            }
          }
          case '8': {
            switch (buf[10]) {
              case '_': {
                switch (buf[11]) {
                  case 'l':
                    if (op == "v128.load8_lane"sv) {
                      CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load8LaneVec128, 1));
                      return Ok{};
                    }
                    goto parse_error;
                  case 's':
                    if (op == "v128.load8_splat"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8SplatVec128, 1));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              case 'x': {
                switch (buf[13]) {
                  case 's':
                    if (op == "v128.load8x8_s"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8x8SVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  case 'u':
                    if (op == "v128.load8x8_u"sv) {
                      CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8x8UVec128, 8));
                      return Ok{};
                    }
                    goto parse_error;
                  default: goto parse_error;
                }
              }
              default: goto parse_error;
            }
          }
          default: goto parse_error;
        }
      }
      case 'n':
        if (op == "v128.not"sv) {
          CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NotVec128));
          return Ok{};
        }
        goto parse_error;
      case 'o':
        if (op == "v128.or"sv) {
          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrVec128));
          return Ok{};
        }
        goto parse_error;
      case 's': {
        switch (buf[10]) {
          case '\0':
            if (op == "v128.store"sv) {
              CHECK_ERR(makeStore(ctx, pos, annotations, Type::v128, 16, /*isAtomic=*/false));
              return Ok{};
            }
            goto parse_error;
          case '1':
            if (op == "v128.store16_lane"sv) {
              CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store16LaneVec128, 2));
              return Ok{};
            }
            goto parse_error;
          case '3':
            if (op == "v128.store32_lane"sv) {
              CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store32LaneVec128, 4));
              return Ok{};
            }
            goto parse_error;
          case '6':
            if (op == "v128.store64_lane"sv) {
              CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store64LaneVec128, 8));
              return Ok{};
            }
            goto parse_error;
          case '8':
            if (op == "v128.store8_lane"sv) {
              CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store8LaneVec128, 1));
              return Ok{};
            }
            goto parse_error;
          default: goto parse_error;
        }
      }
      case 'x':
        if (op == "v128.xor"sv) {
          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorVec128));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  case 'w': {
    switch (buf[11]) {
      case 'e':
        if (op == "waitqueue.new"sv) {
          CHECK_ERR(makeWaitqueueNew(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      case 'o':
        if (op == "waitqueue.notify"sv) {
          CHECK_ERR(makeWaitqueueNotify(ctx, pos, annotations));
          return Ok{};
        }
        goto parse_error;
      default: goto parse_error;
    }
  }
  default: goto parse_error;
}
parse_error:
  return ctx.in.err(pos, "unrecognized instruction");

// NOLINTEND

// clang-format on