diff --git a/Cargo.lock b/Cargo.lock index 4d40d40..5cee168 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -189,6 +189,7 @@ dependencies = [ name = "codebase-graph" version = "1.6.0" dependencies = [ + "cc", "fs2", "lbug", "libc", @@ -205,8 +206,12 @@ dependencies = [ "tree-sitter-css", "tree-sitter-fortran", "tree-sitter-go", + "tree-sitter-html", + "tree-sitter-javascript", + "tree-sitter-language", "tree-sitter-python", "tree-sitter-rust", + "tree-sitter-typescript", "walkdir", "windows-sys 0.61.2", ] @@ -1591,6 +1596,26 @@ dependencies = [ "tree-sitter-language", ] +[[package]] +name = "tree-sitter-html" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "261b708e5d92061ede329babaaa427b819329a9d427a1d710abb0f67bbef63ee" +dependencies = [ + "cc", + "tree-sitter-language", +] + +[[package]] +name = "tree-sitter-javascript" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68204f2abc0627a90bdf06e605f5c470aa26fdcb2081ea553a04bdad756693f5" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "tree-sitter-language" version = "0.1.7" @@ -1617,6 +1642,16 @@ dependencies = [ "tree-sitter-language", ] +[[package]] +name = "tree-sitter-typescript" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c5f76ed8d947a75cc446d5fccd8b602ebf0cde64ccf2ffa434d873d7a575eff" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "typenum" version = "1.20.1" diff --git a/Cargo.toml b/Cargo.toml index f8bcbd7..85c1e57 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,9 +12,11 @@ keywords = ["codebase", "graph", "mcp", "cli", "analysis"] categories = ["command-line-utilities", "development-tools"] include = [ "src/**", + "!src/**/.DS_Store", "tests/**", "assets/*.json", "assets/ladybug-extensions/0.19.0/**/*.xz", + "vendor/tree-sitter-wat/**", "build.rs", "README.md", "LICENSE", @@ -47,10 +49,17 @@ tree-sitter-cpp = "0.23.4" tree-sitter-css = "0.25.0" tree-sitter-fortran = "0.6.0" tree-sitter-go = "0.25.0" +tree-sitter-html = "0.23.2" +tree-sitter-javascript = "0.25.0" +tree-sitter-language = "0.1" tree-sitter-python = "0.25.0" tree-sitter-rust = "0.24.2" +tree-sitter-typescript = "0.23.2" walkdir = "2" +[build-dependencies] +cc = "1.2" + [target.'cfg(windows)'.dependencies] windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_System_ProcessStatus", "Win32_System_Threading"] } diff --git a/README.md b/README.md index 8f7648b..64e5d81 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,10 @@ # codebaseGraph `codebaseGraph` turns a local source repository into a searchable code graph for -AI coding agents. It indexes Python, Rust, Go, C, C++, Fortran, CSS, Markdown, -and MDX, then exposes compact context, schema information, query helpers, and -bounded read-only graph queries through a native CLI and MCP server. +AI coding agents. It indexes Python, Rust, Go, C, C++, Fortran, CSS, HTML, +JavaScript, JSX, TypeScript, TSX, WebAssembly Text, Markdown, and MDX, then +exposes compact context, schema information, query helpers, and bounded +read-only graph queries through a native CLI and MCP server. This workspace also ships `k-wiki`, an optional subsystem for curated repository knowledge. The graph and wiki have separate source and generated state. diff --git a/build.rs b/build.rs index 059c4ad..6372e4e 100644 --- a/build.rs +++ b/build.rs @@ -1,4 +1,6 @@ fn main() { + build_tree_sitter_wat(); + if !cfg!(windows) && std::env::var_os("LBUG_SHARED").is_none() { println!("cargo:rustc-link-arg=-rdynamic"); } @@ -32,6 +34,31 @@ fn main() { } } +fn build_tree_sitter_wat() { + let source_dir = std::path::Path::new("vendor/tree-sitter-wat/src"); + let parser = source_dir.join("parser.c"); + let scanner = source_dir.join("scanner.c"); + + let mut build = cc::Build::new(); + build + .std("c11") + .include(source_dir) + .flag_if_supported("-Wno-unused-parameter") + .file(&parser) + .file(&scanner); + if std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("msvc") { + build.flag("-utf-8"); + } + build.compile("tree-sitter-wat"); + + println!("cargo:rerun-if-changed={}", parser.display()); + println!("cargo:rerun-if-changed={}", scanner.display()); + println!( + "cargo:rerun-if-changed={}", + source_dir.join("tree_sitter/parser.h").display() + ); +} + fn link_macos_x86_compiler_runtime() { println!("cargo:rerun-if-env-changed=DEVELOPER_DIR"); let output = std::process::Command::new("xcrun") diff --git a/knowledge/architecture/language-html.md b/knowledge/architecture/language-html.md new file mode 100644 index 0000000..93ce18b --- /dev/null +++ b/knowledge/architecture/language-html.md @@ -0,0 +1,27 @@ +--- +description: Built-in HTML discovery, grammar, syntax-catalog, and conservative graph-normalization contract. +resource: repository-architecture +tags: +- architecture +- html +- language-support +- parser +- tree-sitter +timestamp: 2026-08-25 +title: HTML Parsing Contract +type: architecture +--- +# HTML Parsing Contract + +The Graph Runtime indexes HTML with a built-in Tree-sitter profile while preserving the distinction between raw markup syntax and higher-level application components. + +## Public contract + +- `html` recognizes `.html` and `.htm` using `tree_sitter_html@0.23.2`. +- The key is advertised by the CLI syntax catalog and MCP `graph_syntax` schema. +- Ordered raw syntax includes documents, doctypes, elements, tags, scripts, styles, attributes, and text. +- HTML elements are not promoted to ontology `Component` nodes because markup alone does not establish framework or component identity. + +Embedded JavaScript and CSS injection parsing is outside this contract; standalone files are handled by their own language profiles. + +Related: [Graph Runtime](./graph-runtime.md) and [Repository Ownership Map](./repository-map.md). \ No newline at end of file diff --git a/knowledge/architecture/language-javascript.md b/knowledge/architecture/language-javascript.md new file mode 100644 index 0000000..40fc06a --- /dev/null +++ b/knowledge/architecture/language-javascript.md @@ -0,0 +1,28 @@ +--- +description: Built-in JavaScript and JSX discovery, grammar, catalog, and semantic-normalization contract. +resource: repository-architecture +tags: +- architecture +- javascript +- jsx +- language-support +- parser +- tree-sitter +timestamp: 2026-08-25 +title: JavaScript and JSX Parsing Contract +type: architecture +--- +# JavaScript and JSX Parsing Contract + +The Graph Runtime exposes JavaScript as one built-in syntax language backed by the Tree-sitter JavaScript grammar, which includes JSX syntax. + +## Public contract + +- `javascript` recognizes `.js`, `.jsx`, `.mjs`, and `.cjs` using `tree_sitter_javascript@0.25.0`. +- The key is advertised by the CLI syntax catalog and MCP `graph_syntax` schema. +- Classes, functions, generator functions, methods, imports, and calls map to established ontology nodes. +- JSX elements remain available through ordered raw syntax captures; they are not promoted to framework-specific component nodes. + +Framework inference and embedded-language extraction are outside this contract. + +Related: [Graph Runtime](./graph-runtime.md) and [Repository Ownership Map](./repository-map.md). \ No newline at end of file diff --git a/knowledge/architecture/language-typescript-tsx.md b/knowledge/architecture/language-typescript-tsx.md new file mode 100644 index 0000000..6cb7470 --- /dev/null +++ b/knowledge/architecture/language-typescript-tsx.md @@ -0,0 +1,28 @@ +--- +description: Built-in TypeScript and TSX discovery, grammar, catalog, and semantic-normalization contract. +resource: repository-architecture +tags: +- architecture +- language-support +- parser +- tree-sitter +- typescript +- tsx +timestamp: 2026-08-25 +title: TypeScript and TSX Parsing Contract +type: architecture +--- +# TypeScript and TSX Parsing Contract + +The Graph Runtime treats TypeScript and TSX as sibling built-in syntax languages so each file selects the correct Tree-sitter grammar and node catalog without changing the one-grammar-per-language profile contract. + +## Public contract + +- `typescript` recognizes `.ts`, `.mts`, and `.cts` using `tree_sitter_typescript@0.23.2`. +- `tsx` recognizes `.tsx` using the TSX grammar and node catalog from the same package version. +- Both keys are advertised by the CLI syntax catalog and MCP `graph_syntax` schema. +- TypeScript declarations, interfaces, enums, type aliases, functions, methods, imports, and calls map to established ontology nodes. JSX/TSX elements remain available through ordered raw syntax captures. + +Framework-specific template semantics and embedded-language extraction are outside this contract. + +Related: [Graph Runtime](./graph-runtime.md) and [Repository Ownership Map](./repository-map.md). \ No newline at end of file diff --git a/knowledge/architecture/language-webassembly.md b/knowledge/architecture/language-webassembly.md new file mode 100644 index 0000000..200ac74 --- /dev/null +++ b/knowledge/architecture/language-webassembly.md @@ -0,0 +1,35 @@ +--- +description: Built-in WebAssembly Text discovery, vendored grammar, syntax-catalog, and semantic-normalization contract. +resource: repository-architecture +tags: +- architecture +- language-support +- parser +- tree-sitter +- webassembly +- wat +timestamp: 2026-08-25 +title: WebAssembly Text Parsing Contract +type: architecture +--- +# WebAssembly Text Parsing Contract + +The Graph Runtime indexes WebAssembly Text files through a built-in profile backed by a pinned, vendored Tree-sitter WAT grammar. + +## Public contract + +- `webassembly` recognizes `.wat` files using `tree_sitter_wat@0.1.0+e3769473`. +- The language key is advertised by the CLI syntax catalog and MCP `graph_syntax` schema. +- Named modules, functions, and type definitions map to `Module`, `Function`, and `TypeAlias` ontology nodes. +- Imports normalize to `module.item`; exports use their declared string name; direct `call` and `return_call` instructions use the referenced index or identifier. +- Anonymous modules, functions, and type definitions remain available as ordered raw syntax without fabricated semantic identities. + +Binary `.wasm` decoding, `.wast` scripts, validation, execution, and disassembly are outside this contract. + +## Vendored grammar + +The generated native parser, external scanner, headers, node catalog, license, and exact upstream provenance live under `vendor/tree-sitter-wat`. The grammar is pinned to upstream commit `e3769473b2d90643d8af500b5cfc2f25a674888a` and compiled by the package build script so crates.io source packages build offline. + +The upstream payload-free scanner callbacks are locally corrected to return zero explicitly. Upstream and patched SHA-256 values are retained in the vendor provenance document. Grammar updates must replace the generated set atomically, preserve license and provenance, verify ABI compatibility, and pass parser, native, and crates.io package checks. + +Related: [Graph Runtime](./graph-runtime.md), [Repository Ownership Map](./repository-map.md), and [Native Release Verification](./release-verification.md). diff --git a/knowledge/memory/procedural/cargo-package-ignored-metadata-clean-worktree-2026-08-25.md b/knowledge/memory/procedural/cargo-package-ignored-metadata-clean-worktree-2026-08-25.md new file mode 100644 index 0000000..6e5835e --- /dev/null +++ b/knowledge/memory/procedural/cargo-package-ignored-metadata-clean-worktree-2026-08-25.md @@ -0,0 +1,37 @@ +--- +agent_memory: + version: 1 + kind: procedural + scope: repository + status: candidate + owner: codex + created_at: 2026-08-25T12:39:22+09:30 + last_verified_at: null + verified_by: null + review_after: null + supersedes: [] + superseded_by: null + sources: + - kind: source + reference: Cargo.toml package include = ["src/**", ...] + content_hash: null + - kind: runtime-observation + reference: 2026-08-25 cargo publish dry-run for PR branches 101-104 + content_hash: null + - kind: pull-request + reference: https://github.com/rabii-chaarani/codebaseGraph/pull/101 + content_hash: null + history: [] +description: Ignored Finder metadata under src/** can make cargo publish dirty and contaminate exact package measurements even when git status is clean. +tags: +- cargo +- packaging +- release-verification +- clean-worktree +timestamp: 2026-08-25T12:39:22+09:30 +title: Verify Cargo packages from a clean worktree when include globs are broad +type: agent-memory +--- +When `Cargo.toml` uses a broad package allowlist such as `src/**`, ignored untracked files beneath that tree can still make `cargo publish --dry-run` report a dirty package. During the web-language PRs, local `src/.DS_Store` and `src/adapters/.DS_Store` triggered this condition even though ordinary `git status` was clean. + +For release-representative verification, preserve user metadata and run `cargo publish --dry-run --locked` from a clean detached worktree at the exact commit. Then pass the produced `.crate` to the xtask size gate. When verifying a version already present on crates.io, Cargo may retain the archive under `target/package/tmp-crate/`; use the path Cargo actually produced rather than assuming the top-level package path. \ No newline at end of file diff --git a/knowledge/memory/procedural/vendored-tree-sitter-scanner-callback-contract-2026-08-25.md b/knowledge/memory/procedural/vendored-tree-sitter-scanner-callback-contract-2026-08-25.md new file mode 100644 index 0000000..6087c8d --- /dev/null +++ b/knowledge/memory/procedural/vendored-tree-sitter-scanner-callback-contract-2026-08-25.md @@ -0,0 +1,47 @@ +--- +agent_memory: + version: 1 + kind: procedural + scope: repository + status: active + owner: codex + created_at: 2026-08-25T13:21:26+09:30 + last_verified_at: 2026-08-25T13:21:40+09:30 + verified_by: codex + review_after: null + supersedes: [] + superseded_by: null + sources: + - kind: source + reference: vendor/tree-sitter-wat/src/scanner.c + content_hash: null + - kind: documentation + reference: vendor/tree-sitter-wat/UPSTREAM.md + content_hash: null + - kind: source + reference: build.rs and Cargo.toml + content_hash: null + - kind: test + reference: cargo test --workspace --locked and cargo publish --dry-run --locked --allow-dirty + content_hash: null + history: + - from: candidate + to: active + actor: codex + at: 2026-08-25T13:21:40+09:30 + reason: Reviewed the callback claim against the pinned upstream scanner, the documented upstream and patched hashes, the local C patch, a warning-clean build, the passing full workspace suite, and the verified extracted source package. +description: Vendored Tree-sitter external scanners must return valid payload and serialization values even when upstream builds only warn. +tags: +- c +- ffi +- parser +- supply-chain +- tree-sitter +- vendoring +timestamp: 2026-08-25T13:21:26+09:30 +title: Verify external-scanner callback returns when vendoring Tree-sitter grammars +type: agent-memory +--- +When vendoring generated Tree-sitter grammar sources, compile the external scanner with warnings enabled and inspect every callback against Tree-sitter's scanner ABI. The pinned `g-plane/tree-sitter-wat` scanner had two payload-free callbacks that compiled but violated their C return contracts: `tree_sitter_wat_external_scanner_create` fell off a non-void function, and `serialize` returned `1` without writing a byte. This can propagate an indeterminate payload pointer or nondeterministic serialized state. + +For a stateless scanner, make `create` return null/zero and `serialize` return zero. Preserve the upstream source hash and the patched vendored hash in provenance rather than presenting the local file as byte-for-byte upstream. Then verify the focused parser tests, full native workspace suite, extracted crates.io package build, and package-size gate. Recheck the callbacks and provenance whenever the grammar commit changes. \ No newline at end of file diff --git a/src/adapters/cli/format/help.rs b/src/adapters/cli/format/help.rs index a981b65..5ff4cba 100644 --- a/src/adapters/cli/format/help.rs +++ b/src/adapters/cli/format/help.rs @@ -43,7 +43,7 @@ pub(in crate::adapters::cli) fn graph_schema_help() -> &'static str { } pub(in crate::adapters::cli) fn graph_syntax_help() -> &'static str { - "codebase-graph syntax\n\nUSAGE:\n codebase-graph syntax [--format json|block] [--json] [--pretty]\n\nOPTIONS:\n One of c, cpp, css, fortran, go, markdown, python, or rust\n --format block or json; defaults to block\n --json Emit compact JSON output\n --pretty Pretty-print JSON output" + "codebase-graph syntax\n\nUSAGE:\n codebase-graph syntax [--format json|block] [--json] [--pretty]\n\nOPTIONS:\n One of c, cpp, css, fortran, go, html, javascript, markdown, python, rust, tsx, typescript, or webassembly\n --format block or json; defaults to block\n --json Emit compact JSON output\n --pretty Pretty-print JSON output" } pub(in crate::adapters::cli) fn graph_query_helpers_help() -> &'static str { diff --git a/src/adapters/cli/tests/dispatch_materialize.rs b/src/adapters/cli/tests/dispatch_materialize.rs index 3e499ee..db9d9fd 100644 --- a/src/adapters/cli/tests/dispatch_materialize.rs +++ b/src/adapters/cli/tests/dispatch_materialize.rs @@ -276,9 +276,77 @@ fn materialize_css_source_root_without_profiles() { ".card { color: red; width: calc(100% - 1rem); }\n", ) .unwrap(); + assert_materializes_language(&root, "styles.css", "css"); + let _ = fs::remove_dir_all(root); +} + +#[test] +fn materialize_typescript_and_tsx_source_root_without_profiles() { + let root = unique_temp_dir("codebase-graph-ts-source-root"); + fs::create_dir_all(&root).unwrap(); + fs::write( + root.join("service.ts"), + "export function helper(): number { return 1; }\n", + ) + .unwrap(); + fs::write( + root.join("component.tsx"), + "export function Card() { return
Hello
; }\n", + ) + .unwrap(); + assert_materializes_languages( + &root, + &[("service.ts", "typescript"), ("component.tsx", "tsx")], + ); + let _ = fs::remove_dir_all(root); +} + +#[test] +fn materialize_javascript_source_root_without_profiles() { + let root = unique_temp_dir("codebase-graph-js-source-root"); + fs::create_dir_all(&root).unwrap(); + fs::write( + root.join("component.jsx"), + "export function Card() { return
Hello
; }\n", + ) + .unwrap(); + assert_materializes_language(&root, "component.jsx", "javascript"); + let _ = fs::remove_dir_all(root); +} + +#[test] +fn materialize_html_source_root_without_profiles() { + let root = unique_temp_dir("codebase-graph-html-source-root"); + fs::create_dir_all(&root).unwrap(); + fs::write( + root.join("index.html"), + "
Welcome
\n", + ) + .unwrap(); + assert_materializes_language(&root, "index.html", "html"); + let _ = fs::remove_dir_all(root); +} + +#[test] +fn materialize_webassembly_source_root_without_profiles() { + let root = unique_temp_dir("codebase-graph-webassembly-source-root"); + fs::create_dir_all(&root).unwrap(); + fs::write( + root.join("math.wat"), + "(module $math (func $add (param i32 i32) (result i32) local.get 0 local.get 1 i32.add))\n", + ) + .unwrap(); + assert_materializes_language(&root, "math.wat", "webassembly"); + let _ = fs::remove_dir_all(root); +} + +fn assert_materializes_language(root: &Path, path: &str, language: &str) { + assert_materializes_languages(root, &[(path, language)]); +} + +fn assert_materializes_languages(root: &Path, expected: &[(&str, &str)]) { let db_path = root.join(".codebaseGraph").join("graph.ldb"); let manifest_path = root.join(".codebaseGraph").join("manifest.json"); - let mut output = Vec::new(); run( [ @@ -303,8 +371,9 @@ fn materialize_css_source_root_without_profiles() { assert_eq!(value["database_written"], true); let manifest: serde_json::Value = serde_json::from_str(&fs::read_to_string(&manifest_path).unwrap()).unwrap(); - assert_eq!(manifest["files"]["styles.css"]["language"], "css"); - let _ = fs::remove_dir_all(root); + for (path, language) in expected { + assert_eq!(manifest["files"][path]["language"], *language); + } } #[test] diff --git a/src/adapters/cli/tests/graph.rs b/src/adapters/cli/tests/graph.rs index 2368fe9..5c4e260 100644 --- a/src/adapters/cli/tests/graph.rs +++ b/src/adapters/cli/tests/graph.rs @@ -40,6 +40,48 @@ fn graph_syntax_outputs_language_catalog_and_validates_language() { .as_array() .is_some_and(|nodes| nodes.iter().any(|node| node["type"] == "rule_set"))); + let mut tsx_output = Vec::new(); + run(["syntax", "tsx", "--json"], &mut tsx_output).unwrap(); + let tsx: serde_json::Value = serde_json::from_slice(&tsx_output).unwrap(); + assert_eq!(tsx["language"], "tsx"); + assert!(tsx["node_types"] + .as_array() + .is_some_and(|nodes| nodes.iter().any(|node| node["type"] == "jsx_element"))); + + let mut javascript_output = Vec::new(); + run(["syntax", "javascript", "--json"], &mut javascript_output).unwrap(); + let javascript: serde_json::Value = serde_json::from_slice(&javascript_output).unwrap(); + assert_eq!(javascript["language"], "javascript"); + assert!(javascript["node_types"] + .as_array() + .is_some_and(|nodes| nodes.iter().any(|node| node["type"] == "jsx_element"))); + + let mut html_output = Vec::new(); + run(["syntax", "html", "--json"], &mut html_output).unwrap(); + let html: serde_json::Value = serde_json::from_slice(&html_output).unwrap(); + assert_eq!(html["language"], "html"); + assert!(html["node_types"] + .as_array() + .is_some_and(|nodes| nodes.iter().any(|node| node["type"] == "element"))); + + let mut webassembly_output = Vec::new(); + run(["syntax", "webassembly", "--json"], &mut webassembly_output).unwrap(); + let webassembly: serde_json::Value = serde_json::from_slice(&webassembly_output).unwrap(); + assert_eq!(webassembly["language"], "webassembly"); + assert_eq!( + webassembly["grammar_version"], + "tree_sitter_wat@0.1.0+e3769473" + ); + assert!(webassembly["node_types"] + .as_array() + .unwrap() + .iter() + .any(|node| node["type"] == "module_field_func")); + + let mut help = Vec::new(); + run(["syntax", "--help"], &mut help).unwrap(); + assert!(String::from_utf8(help).unwrap().contains("webassembly")); + let error = run(["syntax", "custom"], &mut Vec::new()).unwrap_err(); assert!(error.contains("Unknown syntax language")); assert!(run(["syntax"], &mut Vec::new()) @@ -353,6 +395,11 @@ fn setup_indexes_documented_language_defaults() { "module fortran_service\ncontains\nsubroutine fortran_helper()\nuse iso_fortran_env\ncall run()\nend subroutine fortran_helper\nend module fortran_service\n", ) .unwrap(); + fs::write( + root.join("src/service.wat"), + "(module $wasm_service\n (type $binary (func (param i32 i32) (result i32)))\n (import \"env\" \"log\" (func $log (param i32)))\n (func $wasm_helper (export \"add\") (param i32 i32) (result i32)\n local.get 0\n call $log\n local.get 1\n i32.add))\n", + ) + .unwrap(); let mut setup_output = Vec::new(); run( @@ -389,6 +436,7 @@ fn setup_indexes_documented_language_defaults() { "src/service.c", "src/service.cpp", "src/solver.f90", + "src/service.wat", ] { assert!( manifest["files"].get(path).is_some(), @@ -402,6 +450,10 @@ fn setup_indexes_documented_language_defaults() { "CService", "CppService", "fortran_service", + "$wasm_service", + "$wasm_helper", + "$binary", + "env.log", ] { let mut search_output = Vec::new(); run( diff --git a/src/adapters/mcp/tools.rs b/src/adapters/mcp/tools.rs index 7962797..1c63934 100644 --- a/src/adapters/mcp/tools.rs +++ b/src/adapters/mcp/tools.rs @@ -228,7 +228,21 @@ mod tests { assert_eq!(syntax["inputSchema"]["required"], json!(["language"])); assert_eq!( syntax["inputSchema"]["properties"]["language"]["enum"], - json!(["c", "cpp", "css", "fortran", "go", "markdown", "python", "rust"]) + json!([ + "c", + "cpp", + "css", + "fortran", + "go", + "html", + "javascript", + "markdown", + "python", + "rust", + "tsx", + "typescript", + "webassembly" + ]) ); } } diff --git a/src/api/catalog.rs b/src/api/catalog.rs index 1468725..2a7ded3 100644 --- a/src/api/catalog.rs +++ b/src/api/catalog.rs @@ -196,6 +196,88 @@ mod tests { .is_some_and(Vec::is_empty)); } + #[test] + fn syntax_catalog_distinguishes_typescript_and_tsx_grammars() { + let mut typescript = load_catalog("syntax").expect("syntax catalog index should load"); + filter_catalog("syntax", &mut typescript, Some("typescript")) + .expect("TypeScript syntax catalog should load"); + assert_eq!( + typescript["grammar_version"], + "tree_sitter_typescript@0.23.2" + ); + assert!(typescript["node_types"] + .as_array() + .is_some_and(|nodes| nodes + .iter() + .any(|node| node["type"] == "interface_declaration"))); + + let mut tsx = load_catalog("syntax").expect("syntax catalog index should load"); + filter_catalog("syntax", &mut tsx, Some("tsx")).expect("TSX syntax catalog should load"); + assert!(tsx["node_types"] + .as_array() + .is_some_and(|nodes| nodes.iter().any(|node| node["type"] == "jsx_element"))); + } + + #[test] + fn syntax_catalog_describes_javascript_and_jsx_nodes() { + let mut payload = load_catalog("syntax").expect("syntax catalog index should load"); + filter_catalog("syntax", &mut payload, Some("javascript")) + .expect("JavaScript syntax catalog should load"); + + assert_eq!(payload["grammar_version"], "tree_sitter_javascript@0.25.0"); + let nodes = payload["node_types"] + .as_array() + .expect("node types should be an array"); + assert!(nodes + .iter() + .any(|node| node["type"] == "function_declaration")); + assert!(nodes.iter().any(|node| node["type"] == "jsx_element")); + } + + #[test] + fn syntax_catalog_describes_html_document_nodes() { + let mut payload = load_catalog("syntax").expect("syntax catalog index should load"); + filter_catalog("syntax", &mut payload, Some("html")) + .expect("HTML syntax catalog should load"); + + assert_eq!(payload["grammar_version"], "tree_sitter_html@0.23.2"); + let nodes = payload["node_types"] + .as_array() + .expect("node types should be an array"); + assert!(nodes.iter().any(|node| node["type"] == "document")); + assert!(nodes.iter().any(|node| node["type"] == "element")); + assert!(payload["capture_mappings"] + .as_array() + .is_some_and(Vec::is_empty)); + } + + #[test] + fn syntax_catalog_describes_webassembly_nodes_and_captures() { + let mut payload = load_catalog("syntax").expect("syntax catalog index should load"); + filter_catalog("syntax", &mut payload, Some("webassembly")) + .expect("WebAssembly syntax catalog should load"); + + assert_eq!(payload["grammar_package"], "tree_sitter_wat"); + assert_eq!(payload["grammar_version"], "tree_sitter_wat@0.1.0+e3769473"); + assert_eq!(payload["root_node_types"][0], "root"); + let node_types = payload["node_types"] + .as_array() + .expect("node types should be an array"); + assert!(node_types.iter().any(|node| node["type"] == "root")); + assert!(node_types + .iter() + .any(|node| node["type"] == "module_field_func")); + let captures = payload["capture_mappings"] + .as_array() + .expect("capture mappings should be an array"); + assert!(captures + .iter() + .any(|mapping| mapping["capture_name"] == "definition.function")); + assert!(captures + .iter() + .any(|mapping| mapping["capture_name"] == "reference.call")); + } + #[test] fn syntax_catalog_rejects_missing_and_unsupported_languages() { let mut payload = load_catalog("syntax").expect("syntax catalog index should load"); @@ -205,6 +287,8 @@ mod tests { ); assert!(filter_catalog("syntax", &mut payload, Some("custom")) .unwrap_err() - .contains("Valid languages: c, cpp, css, fortran, go, markdown, python, rust")); + .contains( + "Valid languages: c, cpp, css, fortran, go, html, javascript, markdown, python, rust, tsx, typescript, webassembly" + )); } } diff --git a/src/api/lifecycle.rs b/src/api/lifecycle.rs index 9476553..177dc0e 100644 --- a/src/api/lifecycle.rs +++ b/src/api/lifecycle.rs @@ -717,14 +717,23 @@ fn scan_source_snapshots_inner( } fn language_for_path(path: &Path) -> Option<&'static str> { - match path.extension().and_then(|value| value.to_str()) { + let extension = path + .extension() + .and_then(|value| value.to_str()) + .map(str::to_ascii_lowercase); + match extension.as_deref() { Some("py") => Some("python"), Some("rs") => Some("rust"), Some("go") => Some("go"), Some("css") => Some("css"), + Some("ts") | Some("mts") | Some("cts") => Some("typescript"), + Some("tsx") => Some("tsx"), + Some("js") | Some("jsx") | Some("mjs") | Some("cjs") => Some("javascript"), + Some("html") | Some("htm") => Some("html"), Some("c") | Some("h") => Some("c"), Some("cc") | Some("cpp") | Some("cxx") | Some("hpp") | Some("hh") => Some("cpp"), Some("f") | Some("f90") | Some("f95") | Some("for") => Some("fortran"), + Some("wat") => Some("webassembly"), _ => None, } } @@ -4495,14 +4504,14 @@ fn install_safe_name(value: &str) -> String { mod tests { use super::{ codex_toml_block, descriptor_signature, hermes_yaml_block_from_entries, inspect_mcp_server, - install_mcp_endpoint, install_mcp_server, instruction_block, native_client_command, - parse_hermes_managed_entries, parse_toml_stdio_entry, reinstall_state, remove_mcp_server, - remove_partial_state_tree, rename_mcp_server, render_client_http_config, - resolve_mcp_target, run_reinstall_activation_boundary, select_available_daemon_port, - upsert_instruction_text, yaml_scalar, GraphStatePaths, ManagedStdioEntry, - McpClientInstallOptions, McpClientRemovalOptions, McpClientRenameOptions, - McpEndpointDescriptor, McpExistingEntryPolicy, McpInstallMode, McpServerDescriptor, - McpTargetLocality, ResolvedMcpTarget, + install_mcp_endpoint, install_mcp_server, instruction_block, language_for_path, + native_client_command, parse_hermes_managed_entries, parse_toml_stdio_entry, + reinstall_state, remove_mcp_server, remove_partial_state_tree, rename_mcp_server, + render_client_http_config, resolve_mcp_target, run_reinstall_activation_boundary, + select_available_daemon_port, upsert_instruction_text, yaml_scalar, GraphStatePaths, + ManagedStdioEntry, McpClientInstallOptions, McpClientRemovalOptions, + McpClientRenameOptions, McpEndpointDescriptor, McpExistingEntryPolicy, McpInstallMode, + McpServerDescriptor, McpTargetLocality, ResolvedMcpTarget, }; use serde_json::json; use std::collections::BTreeMap; @@ -4544,6 +4553,20 @@ mod tests { } } + #[test] + fn dry_run_language_detection_recognizes_webassembly_case_insensitively() { + assert_eq!( + language_for_path(Path::new("module.wat")), + Some("webassembly") + ); + assert_eq!( + language_for_path(Path::new("MODULE.WAT")), + Some("webassembly") + ); + assert_eq!(language_for_path(Path::new("module.wast")), None); + assert_eq!(language_for_path(Path::new("module.wasm")), None); + } + fn test_descriptor(repo_root: &Path, name: &str) -> McpServerDescriptor { McpServerDescriptor { name: name.to_string(), diff --git a/src/normalize.rs b/src/normalize.rs index 82544b4..df26c26 100644 --- a/src/normalize.rs +++ b/src/normalize.rs @@ -52,6 +52,13 @@ fn context_rule_matches(rule: &str, node: &SyntaxNode, ancestors: &[String]) -> if let Some(expected_type) = normalized.strip_prefix("type is ") { return field_type_matches(node, "type", expected_type); } + if let Some(field_name) = normalized.strip_prefix("has ") { + return node + .fields + .get(field_name) + .and_then(Value::as_str) + .is_some_and(|value| !value.is_empty()); + } if normalized == "qualified declarator" { return field_descendant_has(node, "declarator", "qualified_identifier"); } diff --git a/src/parser/fields.rs b/src/parser/fields.rs index 707a096..a1bc4a5 100644 --- a/src/parser/fields.rs +++ b/src/parser/fields.rs @@ -72,13 +72,46 @@ pub(super) fn augment_field_metadata( } if matches!( node_type, - "use_declaration" | "import_declaration" | "preproc_include" | "use_statement" + "use_declaration" + | "import_declaration" + | "preproc_include" + | "use_statement" + | "module_field_import" ) { - let module = import_module(node, source_bytes); + let module = if node_type == "module_field_import" { + wat_import_parts(node, source_bytes).0 + } else { + import_module(node, source_bytes) + }; if !module.is_empty() { fields.insert("module".to_string(), json!(module)); } } + if node_type == "module_field_import" { + let imported_name = wat_import_parts(node, source_bytes).1; + if !imported_name.is_empty() { + fields.insert( + "names".to_string(), + json!([{"type": "alias", "name": imported_name}]), + ); + } + } + if matches!(node_type, "module_field_export" | "export") { + let name = direct_named_child_text(node, source_bytes, &["string"]); + let name = strip_import_delimiters(&name); + if !name.is_empty() { + fields.insert("name".to_string(), json!(name)); + } + } + if node_type == "plain_instr" { + let instruction = direct_named_child_text(node, source_bytes, &["instr_name"]); + if matches!(instruction.as_str(), "call" | "return_call") { + let function = direct_named_child_text(node, source_bytes, &["identifier", "uinteger"]); + if !function.is_empty() { + fields.insert("function".to_string(), json!(function)); + } + } + } if matches!(node_type, "call_expression" | "subroutine_call") && !fields.contains_key("function") { @@ -261,7 +294,10 @@ pub(super) fn derived_name(node: Node<'_>, source_bytes: &[u8]) -> String { }) .and_then(|name| node_text(name, source_bytes)) .map(|value| clean_label(&value)) - .unwrap_or_default() + .unwrap_or_else(|| direct_named_child_text(node, source_bytes, &["identifier"])) + } + "module_field_func" | "type_def" => { + direct_named_child_text(node, source_bytes, &["identifier"]) } "package_clause" => { first_descendant_text(node, source_bytes, &["package_identifier", "identifier"]) @@ -270,6 +306,32 @@ pub(super) fn derived_name(node: Node<'_>, source_bytes: &[u8]) -> String { } } +fn wat_import_parts(node: Node<'_>, source_bytes: &[u8]) -> (String, String) { + let strings = named_children(node) + .into_iter() + .filter(|child| child.kind() == "string") + .filter_map(|child| node_text(child, source_bytes)) + .map(|value| strip_import_delimiters(&value)) + .collect::>(); + ( + strings.first().cloned().unwrap_or_default(), + strings.get(1).cloned().unwrap_or_default(), + ) +} + +fn direct_named_child_text(node: Node<'_>, source_bytes: &[u8], node_types: &[&str]) -> String { + named_children(node) + .into_iter() + .find(|child| { + node_types + .iter() + .any(|node_type| child.kind() == *node_type) + }) + .and_then(|child| node_text(child, source_bytes)) + .map(|value| clean_label(&value)) + .unwrap_or_default() +} + pub(super) fn declarator_name(node: Option>, source_bytes: &[u8]) -> String { let Some(node) = node else { return String::new(); diff --git a/src/parser/mod.rs b/src/parser/mod.rs index b4d852d..1ce2b29 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -2,6 +2,7 @@ mod captures; mod fields; mod markdown; mod tree_sitter; +mod wat; use crate::error::NativeError; use crate::normalize::SyntaxNode; @@ -147,6 +148,133 @@ mod tests { assert!(marked_captures(&output.root).is_empty()); } + #[test] + fn typescript_tree_sitter_parser_marks_profile_captures() { + let output = parse_source( + "import { value } from './dep';\ninterface Service { run(): void }\ntype Id = string;\nclass Worker implements Service { run() { value(); } }\nfunction helper(): Id { return 'ok'; }\n", + &profile("typescript"), + ) + .expect("TypeScript parsing should succeed"); + + let captures = marked_captures(&output.root); + assert!(captures + .iter() + .any(|(capture, _)| capture == "reference.import")); + assert!(captures.contains(&("definition.interface".to_string(), "Service".to_string()))); + assert!(captures.contains(&("definition.type_alias".to_string(), "Id".to_string()))); + assert!(captures.contains(&("definition.class".to_string(), "Worker".to_string()))); + assert!(captures.contains(&("definition.method".to_string(), "run".to_string()))); + assert!(captures.contains(&("definition.function".to_string(), "helper".to_string()))); + assert!(captures.contains(&("reference.call".to_string(), "value".to_string()))); + assert_eq!(output.root.node_type, "program"); + assert!(output.diagnostics.is_empty()); + } + + #[test] + fn tsx_tree_sitter_parser_uses_the_tsx_grammar() { + let output = parse_source( + "export function Card() { return

Hello

; }\n", + &profile("tsx"), + ) + .expect("TSX parsing should succeed"); + + assert_eq!(output.root.node_type, "program"); + assert!(output.diagnostics.is_empty()); + assert!(contains_node_type(&output.root, "jsx_element")); + } + + #[test] + fn javascript_tree_sitter_parser_marks_profile_captures_and_jsx() { + let output = parse_source( + "import { value } from './dep.js';\nclass Worker { run() { value(); } }\nfunction Card() { return
Hello
; }\n", + &profile("javascript"), + ) + .expect("JavaScript parsing should succeed"); + + let captures = marked_captures(&output.root); + assert!(captures + .iter() + .any(|(capture, _)| capture == "reference.import")); + assert!(captures.contains(&("definition.class".to_string(), "Worker".to_string()))); + assert!(captures.contains(&("definition.method".to_string(), "run".to_string()))); + assert!(captures.contains(&("definition.function".to_string(), "Card".to_string()))); + assert!(captures.contains(&("reference.call".to_string(), "value".to_string()))); + assert_eq!(output.root.node_type, "program"); + assert!(output.diagnostics.is_empty()); + assert!(contains_node_type(&output.root, "jsx_element")); + } + + #[test] + fn html_tree_sitter_parser_preserves_document_structure() { + let output = parse_source( + "
Welcome
", + &profile("html"), + ) + .expect("HTML parsing should succeed"); + + assert_eq!(output.root.node_type, "document"); + assert!(output.diagnostics.is_empty()); + assert!(contains_node_type(&output.root, "doctype")); + assert!(contains_node_type(&output.root, "element")); + assert!(contains_node_type(&output.root, "style_element")); + assert!(contains_node_type(&output.root, "script_element")); + assert!(marked_captures(&output.root).is_empty()); + } + + #[test] + fn webassembly_tree_sitter_parser_marks_named_semantics() { + let output = parse_source( + r#"(module $math + (type $binary (func (param i32 i32) (result i32))) + (import "env" "log" (func $log (param i32))) + (func $add (export "add") (param i32 i32) (result i32) + local.get 0 + call $log + return_call $log) + (memory 1) + (export "memory" (memory 0))) +"#, + &profile("webassembly"), + ) + .expect("WebAssembly parsing should succeed"); + + let captures = marked_captures(&output.root); + + assert_eq!(output.root.node_type, "root"); + assert!(output.diagnostics.is_empty()); + assert!(captures.contains(&("definition.module".to_string(), "$math".to_string()))); + assert!(captures.contains(&("definition.type_alias".to_string(), "$binary".to_string()))); + assert!(captures.contains(&("definition.function".to_string(), "$add".to_string()))); + assert!(captures.contains(&("reference.import".to_string(), "env".to_string()))); + assert!(captures.contains(&("definition.export".to_string(), "add".to_string()))); + assert!(captures.contains(&("definition.export".to_string(), "memory".to_string()))); + assert_eq!( + captures + .iter() + .filter(|capture| capture.0 == "reference.call" && capture.1 == "$log") + .count(), + 2 + ); + } + + #[test] + fn webassembly_tree_sitter_parser_keeps_anonymous_constructs_syntax_only() { + let output = parse_source( + "(module (type (func)) (func (param i32) local.get 0))\n", + &profile("webassembly"), + ) + .expect("anonymous WebAssembly constructs should parse"); + + let captures = marked_captures(&output.root); + + assert_eq!(output.root.node_type, "root"); + assert!(output.diagnostics.is_empty()); + assert!(captures.iter().all(|(capture, _)| !matches!( + capture.as_str(), + "definition.module" | "definition.function" | "definition.type_alias" + ))); + } + #[test] fn c_tree_sitter_parser_marks_profile_captures() { let output = parse_source( diff --git a/src/parser/tree_sitter.rs b/src/parser/tree_sitter.rs index 77ef3ba..899ebec 100644 --- a/src/parser/tree_sitter.rs +++ b/src/parser/tree_sitter.rs @@ -50,8 +50,17 @@ fn grammar_language(profile: &LanguageProfile) -> Option { ("tree_sitter_css", _) | (_, "css") => Some(tree_sitter_css::LANGUAGE.into()), ("tree_sitter_fortran", _) | (_, "fortran") => Some(tree_sitter_fortran::LANGUAGE.into()), ("tree_sitter_go", _) | (_, "go") => Some(tree_sitter_go::LANGUAGE.into()), + ("tree_sitter_html", _) | (_, "html") => Some(tree_sitter_html::LANGUAGE.into()), + ("tree_sitter_javascript", _) | (_, "javascript") => { + Some(tree_sitter_javascript::LANGUAGE.into()) + } ("tree_sitter_python", _) | (_, "python") => Some(tree_sitter_python::LANGUAGE.into()), ("tree_sitter_rust", _) | (_, "rust") => Some(tree_sitter_rust::LANGUAGE.into()), + (_, "tsx") => Some(tree_sitter_typescript::LANGUAGE_TSX.into()), + ("tree_sitter_typescript", _) | (_, "typescript") => { + Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()) + } + ("tree_sitter_wat", _) | (_, "webassembly") => Some(super::wat::LANGUAGE.into()), _ => None, } } @@ -63,8 +72,17 @@ pub(super) fn grammar_node_types(profile: &LanguageProfile) -> Option<&'static s ("tree_sitter_css", _) | (_, "css") => Some(tree_sitter_css::NODE_TYPES), ("tree_sitter_fortran", _) | (_, "fortran") => Some(tree_sitter_fortran::NODE_TYPES), ("tree_sitter_go", _) | (_, "go") => Some(tree_sitter_go::NODE_TYPES), + ("tree_sitter_html", _) | (_, "html") => Some(tree_sitter_html::NODE_TYPES), + ("tree_sitter_javascript", _) | (_, "javascript") => { + Some(tree_sitter_javascript::NODE_TYPES) + } ("tree_sitter_python", _) | (_, "python") => Some(tree_sitter_python::NODE_TYPES), ("tree_sitter_rust", _) | (_, "rust") => Some(tree_sitter_rust::NODE_TYPES), + (_, "tsx") => Some(tree_sitter_typescript::TSX_NODE_TYPES), + ("tree_sitter_typescript", _) | (_, "typescript") => { + Some(tree_sitter_typescript::TYPESCRIPT_NODE_TYPES) + } + ("tree_sitter_wat", _) | (_, "webassembly") => Some(super::wat::NODE_TYPES), _ => None, } } diff --git a/src/parser/wat.rs b/src/parser/wat.rs new file mode 100644 index 0000000..8e6f070 --- /dev/null +++ b/src/parser/wat.rs @@ -0,0 +1,12 @@ +use tree_sitter_language::LanguageFn; + +extern "C" { + fn tree_sitter_wat() -> *const (); +} + +// SAFETY: `tree_sitter_wat` is generated by Tree-sitter and compiled from the +// pinned sources under `vendor/tree-sitter-wat` by the package build script. +pub(super) const LANGUAGE: LanguageFn = unsafe { LanguageFn::from_raw(tree_sitter_wat) }; + +pub(super) const NODE_TYPES: &str = + include_str!("../../vendor/tree-sitter-wat/src/node-types.json"); diff --git a/src/profiles.rs b/src/profiles.rs index 0813694..0e2834e 100644 --- a/src/profiles.rs +++ b/src/profiles.rs @@ -93,6 +93,51 @@ pub(crate) fn built_in_profiles() -> Vec { root_node_types: vec!["stylesheet".to_string()], capture_mappings: Vec::new(), }, + LanguageProfile { + language: "typescript".to_string(), + suffixes: vec![".ts".to_string(), ".mts".to_string(), ".cts".to_string()], + grammar_package: "tree_sitter_typescript".to_string(), + grammar_version: "tree_sitter_typescript@0.23.2".to_string(), + root_node_types: vec!["program".to_string()], + capture_mappings: typescript_mappings(), + }, + LanguageProfile { + language: "tsx".to_string(), + suffixes: vec![".tsx".to_string()], + grammar_package: "tree_sitter_typescript".to_string(), + grammar_version: "tree_sitter_typescript@0.23.2".to_string(), + root_node_types: vec!["program".to_string()], + capture_mappings: typescript_mappings(), + }, + LanguageProfile { + language: "javascript".to_string(), + suffixes: vec![ + ".js".to_string(), + ".jsx".to_string(), + ".mjs".to_string(), + ".cjs".to_string(), + ], + grammar_package: "tree_sitter_javascript".to_string(), + grammar_version: "tree_sitter_javascript@0.25.0".to_string(), + root_node_types: vec!["program".to_string()], + capture_mappings: javascript_mappings(), + }, + LanguageProfile { + language: "html".to_string(), + suffixes: vec![".html".to_string(), ".htm".to_string()], + grammar_package: "tree_sitter_html".to_string(), + grammar_version: "tree_sitter_html@0.23.2".to_string(), + root_node_types: vec!["document".to_string()], + capture_mappings: Vec::new(), + }, + LanguageProfile { + language: "webassembly".to_string(), + suffixes: vec![".wat".to_string()], + grammar_package: "tree_sitter_wat".to_string(), + grammar_version: "tree_sitter_wat@0.1.0+e3769473".to_string(), + root_node_types: vec!["root".to_string()], + capture_mappings: webassembly_mappings(), + }, LanguageProfile { language: "rust".to_string(), suffixes: vec![".rs".to_string()], @@ -177,6 +222,95 @@ pub(crate) fn built_in_profiles() -> Vec { ] } +fn typescript_mappings() -> Vec { + vec![ + mapping( + "definition.class", + &["class_declaration", "abstract_class_declaration"], + "Class", + ), + mapping("definition.interface", &["interface_declaration"], "Class"), + mapping("definition.enum", &["enum_declaration"], "Class"), + mapping( + "definition.type_alias", + &["type_alias_declaration"], + "TypeAlias", + ), + mapping( + "definition.function", + &["function_declaration", "generator_function_declaration"], + "Function", + ), + mapping( + "definition.method", + &[ + "method_definition", + "method_signature", + "abstract_method_signature", + ], + "Method", + ), + mapping( + "reference.import", + &["import_statement"], + "ImportDeclaration", + ), + mapping("reference.call", &["call_expression"], "CallExpression"), + ] +} + +fn javascript_mappings() -> Vec { + vec![ + mapping("definition.class", &["class_declaration"], "Class"), + mapping( + "definition.function", + &["function_declaration", "generator_function_declaration"], + "Function", + ), + mapping("definition.method", &["method_definition"], "Method"), + mapping( + "reference.import", + &["import_statement"], + "ImportDeclaration", + ), + mapping("reference.call", &["call_expression"], "CallExpression"), + ] +} + +fn webassembly_mappings() -> Vec { + vec![ + mapping_with_context("definition.module", &["module"], "Module", "has name"), + mapping_with_context( + "definition.function", + &["module_field_func"], + "Function", + "has name", + ), + mapping_with_context( + "definition.type_alias", + &["type_def"], + "TypeAlias", + "has name", + ), + mapping( + "reference.import", + &["module_field_import"], + "ImportDeclaration", + ), + mapping( + "definition.export", + &["module_field_export", "export"], + "ExportDeclaration", + ), + mapping_with_context( + "reference.call", + &["plain_instr"], + "CallExpression", + "has function", + ), + ] +} + fn c_family_mappings() -> Vec { vec![ mapping("definition.function", &["function_definition"], "Function"), @@ -239,6 +373,18 @@ mod tests { ("README.md", "markdown"), ("README.mdx", "markdown"), ("styles.css", "css"), + ("service.ts", "typescript"), + ("service.mts", "typescript"), + ("service.cts", "typescript"), + ("component.tsx", "tsx"), + ("service.js", "javascript"), + ("component.jsx", "javascript"), + ("module.mjs", "javascript"), + ("config.cjs", "javascript"), + ("index.html", "html"), + ("legacy.htm", "html"), + ("module.wat", "webassembly"), + ("MODULE.WAT", "webassembly"), ("src/lib.rs", "rust"), ("main.go", "go"), ("service.c", "c"), @@ -261,5 +407,8 @@ mod tests { "{path} should resolve to {language}" ); } + + assert_eq!(profiles.language_for_path(Path::new("module.wast")), None); + assert_eq!(profiles.language_for_path(Path::new("module.wasm")), None); } } diff --git a/vendor/tree-sitter-wat/LICENSE b/vendor/tree-sitter-wat/LICENSE new file mode 100644 index 0000000..646ca39 --- /dev/null +++ b/vendor/tree-sitter-wat/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026-present Pig Fang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/tree-sitter-wat/UPSTREAM.md b/vendor/tree-sitter-wat/UPSTREAM.md new file mode 100644 index 0000000..d306839 --- /dev/null +++ b/vendor/tree-sitter-wat/UPSTREAM.md @@ -0,0 +1,21 @@ +# Vendored tree-sitter-wat grammar + +- Upstream: https://github.com/g-plane/tree-sitter-wat +- Commit: `e3769473b2d90643d8af500b5cfc2f25a674888a` +- Upstream version metadata: `0.1.0` +- License: MIT (see `LICENSE`) +- Generated grammar ABI: 15 + +The repository vendors only the generated native parser inputs and node catalog required to build and describe the grammar offline. Generated files other than `src/scanner.c` were copied byte-for-byte from the pinned upstream commit. The scanner has a local safety correction: its payload-free `create` and `serialize` callbacks explicitly return zero instead of falling off a non-void function or claiming to have written an uninitialized byte. The upstream scanner SHA-256 before that correction is `669f14d7ab816551bce4511d4b39779713bfa5d51962ac2cc2a9c55e44280e69`. The MIT license text is unchanged apart from removing one redundant final blank line; its upstream SHA-256 is `0e373b1e533e7fdf342380a986890d494fcbb25cbc99beca2b46e6d3c726c4c9`. + +| File | SHA-256 | +| --- | --- | +| `LICENSE` | `28a1c2b92a241a705632869e5c3a5e83a53bb182eb273c851565ae381f12982c` | +| `src/parser.c` | `ba3659413ddfa7acd66d1739ca96ace762e6d08f2c60a43d22670503fac87ec6` | +| `src/scanner.c` | `e6197b66843756e44e67ff6e9f61790b7df44c930ed1ba5b5fc1169874fc6d60` | +| `src/node-types.json` | `b8ee14131666f1553d8948fa661526b2aa5d4bc5f64aa5f28f662fb33ebf453a` | +| `src/tree_sitter/alloc.h` | `b29c1c9fb7cc82f58c84b376df1297d6e2737a1d655fd356db0859e3c29c2fea` | +| `src/tree_sitter/array.h` | `5bdf6ed1a78e3409fd443e085ca967a64c188a5d082aaf7f819bccd53a471c94` | +| `src/tree_sitter/parser.h` | `180b893c8734778fd32f372dfbc27bd6ad1cd2221f26150b31256ff6716320d2` | + +When updating the grammar, pin an immutable upstream commit, replace all files as one set, refresh these hashes, verify the Tree-sitter ABI against the runtime, and rerun the parser, cross-platform, and crates.io package checks. diff --git a/vendor/tree-sitter-wat/src/node-types.json b/vendor/tree-sitter-wat/src/node-types.json new file mode 100644 index 0000000..f5b612f --- /dev/null +++ b/vendor/tree-sitter-wat/src/node-types.json @@ -0,0 +1,2011 @@ +[ + { + "type": "addr_type", + "named": true, + "fields": {} + }, + { + "type": "annotation_end", + "named": true, + "fields": {} + }, + { + "type": "array_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "field_type", + "named": true + } + ] + } + }, + { + "type": "block_block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "block_comment", + "named": true, + "extra": true, + "fields": {} + }, + { + "type": "block_if", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_if_else", + "named": true + }, + { + "type": "block_if_then", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "block_if_else", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "plain_instr", + "named": true + } + ] + } + }, + { + "type": "block_if_then", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "plain_instr", + "named": true + } + ] + } + }, + { + "type": "block_loop", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "block_try_table", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "catch", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "catch", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "cont_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "data", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "elem", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "elem_expr", + "named": true + }, + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "elem_expr", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "plain_instr", + "named": true + } + ] + } + }, + { + "type": "elem_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "elem_expr", + "named": true + }, + { + "type": "index", + "named": true + }, + { + "type": "ref_type", + "named": true + } + ] + } + }, + { + "type": "export", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "extern_idx", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "extern_type_func", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "extern_type_global", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "global_type", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "extern_type_memory", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "mem_type", + "named": true + } + ] + } + }, + { + "type": "extern_type_table", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "table_type", + "named": true + } + ] + } + }, + { + "type": "extern_type_tag", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "field", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "field_type", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "field_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "num_type", + "named": true + }, + { + "type": "packed_type", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "vec_type", + "named": true + } + ] + } + }, + { + "type": "float", + "named": true, + "fields": {} + }, + { + "type": "func_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "param", + "named": true + }, + { + "type": "result", + "named": true + } + ] + } + }, + { + "type": "global_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "num_type", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "vec_type", + "named": true + } + ] + } + }, + { + "type": "heap_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "import", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "index", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "uinteger", + "named": true + } + ] + } + }, + { + "type": "local", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "num_type", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "vec_type", + "named": true + } + ] + } + }, + { + "type": "mem_page_size", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "uinteger", + "named": true + } + ] + } + }, + { + "type": "mem_type", + "named": true, + "fields": { + "max": { + "multiple": false, + "required": false, + "types": [ + { + "type": "uinteger", + "named": true + } + ] + }, + "min": { + "multiple": false, + "required": true, + "types": [ + { + "type": "uinteger", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "addr_type", + "named": true + }, + { + "type": "mem_page_size", + "named": true + }, + { + "type": "share", + "named": true + } + ] + } + }, + { + "type": "mem_use", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "module", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "module_field_data", + "named": true + }, + { + "type": "module_field_elem", + "named": true + }, + { + "type": "module_field_export", + "named": true + }, + { + "type": "module_field_func", + "named": true + }, + { + "type": "module_field_global", + "named": true + }, + { + "type": "module_field_import", + "named": true + }, + { + "type": "module_field_memory", + "named": true + }, + { + "type": "module_field_start", + "named": true + }, + { + "type": "module_field_table", + "named": true + }, + { + "type": "module_field_tag", + "named": true + }, + { + "type": "rec_type", + "named": true + }, + { + "type": "type_def", + "named": true + } + ] + } + }, + { + "type": "module_field_data", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "mem_use", + "named": true + }, + { + "type": "offset", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "module_field_elem", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "elem_list", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "offset", + "named": true + }, + { + "type": "table_use", + "named": true + } + ] + } + }, + { + "type": "module_field_export", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "extern_idx", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "module_field_func", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "export", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "local", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "module_field_global", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "export", + "named": true + }, + { + "type": "global_type", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "plain_instr", + "named": true + } + ] + } + }, + { + "type": "module_field_import", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "extern_type_func", + "named": true + }, + { + "type": "extern_type_global", + "named": true + }, + { + "type": "extern_type_memory", + "named": true + }, + { + "type": "extern_type_table", + "named": true + }, + { + "type": "extern_type_tag", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "module_field_memory", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "data", + "named": true + }, + { + "type": "export", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "mem_type", + "named": true + } + ] + } + }, + { + "type": "module_field_start", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "module_field_table", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "elem", + "named": true + }, + { + "type": "export", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "table_type", + "named": true + } + ] + } + }, + { + "type": "module_field_tag", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "export", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "num_type", + "named": true, + "fields": {} + }, + { + "type": "offset", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "plain_instr", + "named": true + } + ] + } + }, + { + "type": "on_clause", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "packed_type", + "named": true, + "fields": {} + }, + { + "type": "param", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "num_type", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "vec_type", + "named": true + } + ] + } + }, + { + "type": "plain_instr", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "block_block", + "named": true + }, + { + "type": "block_if", + "named": true + }, + { + "type": "block_loop", + "named": true + }, + { + "type": "block_try_table", + "named": true + }, + { + "type": "float", + "named": true + }, + { + "type": "heap_type", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "instr_name", + "named": true + }, + { + "type": "integer", + "named": true + }, + { + "type": "mem_arg", + "named": true + }, + { + "type": "on_clause", + "named": true + }, + { + "type": "param", + "named": true + }, + { + "type": "plain_instr", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "result", + "named": true + }, + { + "type": "shape_descriptor", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "type_use", + "named": true + } + ] + } + }, + { + "type": "rec_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "type_def", + "named": true + } + ] + } + }, + { + "type": "ref_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "heap_type", + "named": true + } + ] + } + }, + { + "type": "result", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "num_type", + "named": true + }, + { + "type": "ref_type", + "named": true + }, + { + "type": "vec_type", + "named": true + } + ] + } + }, + { + "type": "root", + "named": true, + "root": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "module", + "named": true + }, + { + "type": "module_field_data", + "named": true + }, + { + "type": "module_field_elem", + "named": true + }, + { + "type": "module_field_export", + "named": true + }, + { + "type": "module_field_func", + "named": true + }, + { + "type": "module_field_global", + "named": true + }, + { + "type": "module_field_import", + "named": true + }, + { + "type": "module_field_memory", + "named": true + }, + { + "type": "module_field_start", + "named": true + }, + { + "type": "module_field_table", + "named": true + }, + { + "type": "module_field_tag", + "named": true + }, + { + "type": "rec_type", + "named": true + }, + { + "type": "type_def", + "named": true + } + ] + } + }, + { + "type": "shape_descriptor", + "named": true, + "fields": {} + }, + { + "type": "share", + "named": true, + "fields": {} + }, + { + "type": "struct_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "field", + "named": true + } + ] + } + }, + { + "type": "sub_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "cont_type", + "named": true + }, + { + "type": "func_type", + "named": true + }, + { + "type": "index", + "named": true + }, + { + "type": "struct_type", + "named": true + } + ] + } + }, + { + "type": "table_type", + "named": true, + "fields": { + "max": { + "multiple": false, + "required": false, + "types": [ + { + "type": "uinteger", + "named": true + } + ] + }, + "min": { + "multiple": false, + "required": true, + "types": [ + { + "type": "uinteger", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "addr_type", + "named": true + }, + { + "type": "ref_type", + "named": true + } + ] + } + }, + { + "type": "table_use", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "type_def", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "sub_type", + "named": true + } + ] + } + }, + { + "type": "type_use", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "index", + "named": true + } + ] + } + }, + { + "type": "(", + "named": false + }, + { + "type": "(;", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": ";)", + "named": false + }, + { + "type": "annotation_elem", + "named": true + }, + { + "type": "annotation_start", + "named": true + }, + { + "type": "any", + "named": false + }, + { + "type": "anyref", + "named": false + }, + { + "type": "array", + "named": false + }, + { + "type": "arrayref", + "named": false + }, + { + "type": "block", + "named": false + }, + { + "type": "catch", + "named": false + }, + { + "type": "catch_all", + "named": false + }, + { + "type": "catch_all_ref", + "named": false + }, + { + "type": "catch_ref", + "named": false + }, + { + "type": "cont", + "named": false + }, + { + "type": "contref", + "named": false + }, + { + "type": "data", + "named": false + }, + { + "type": "declare", + "named": false + }, + { + "type": "elem", + "named": false + }, + { + "type": "else", + "named": false + }, + { + "type": "end", + "named": false + }, + { + "type": "eq", + "named": false + }, + { + "type": "eqref", + "named": false + }, + { + "type": "exn", + "named": false + }, + { + "type": "exnref", + "named": false + }, + { + "type": "export", + "named": false + }, + { + "type": "extern", + "named": false + }, + { + "type": "externref", + "named": false + }, + { + "type": "f32", + "named": false + }, + { + "type": "f32x4", + "named": false + }, + { + "type": "f64", + "named": false + }, + { + "type": "f64x2", + "named": false + }, + { + "type": "field", + "named": false + }, + { + "type": "final", + "named": false + }, + { + "type": "func", + "named": false + }, + { + "type": "funcref", + "named": false + }, + { + "type": "global", + "named": false + }, + { + "type": "i16", + "named": false + }, + { + "type": "i16x8", + "named": false + }, + { + "type": "i31", + "named": false + }, + { + "type": "i31ref", + "named": false + }, + { + "type": "i32", + "named": false + }, + { + "type": "i32x4", + "named": false + }, + { + "type": "i64", + "named": false + }, + { + "type": "i64x2", + "named": false + }, + { + "type": "i8", + "named": false + }, + { + "type": "i8x16", + "named": false + }, + { + "type": "identifier", + "named": true + }, + { + "type": "if", + "named": false + }, + { + "type": "import", + "named": false + }, + { + "type": "instr_name", + "named": true + }, + { + "type": "integer", + "named": true + }, + { + "type": "item", + "named": false + }, + { + "type": "line_comment", + "named": true, + "extra": true + }, + { + "type": "local", + "named": false + }, + { + "type": "loop", + "named": false + }, + { + "type": "mem_arg", + "named": true + }, + { + "type": "memory", + "named": false + }, + { + "type": "module", + "named": false + }, + { + "type": "mut", + "named": false + }, + { + "type": "nocont", + "named": false + }, + { + "type": "noexn", + "named": false + }, + { + "type": "noextern", + "named": false + }, + { + "type": "nofunc", + "named": false + }, + { + "type": "none", + "named": false + }, + { + "type": "null", + "named": false + }, + { + "type": "nullcontref", + "named": false + }, + { + "type": "nullexnref", + "named": false + }, + { + "type": "nullexternref", + "named": false + }, + { + "type": "nullfuncref", + "named": false + }, + { + "type": "nullref", + "named": false + }, + { + "type": "offset", + "named": false + }, + { + "type": "on", + "named": false + }, + { + "type": "pagesize", + "named": false + }, + { + "type": "param", + "named": false + }, + { + "type": "rec", + "named": false + }, + { + "type": "ref", + "named": false + }, + { + "type": "result", + "named": false + }, + { + "type": "shared", + "named": false + }, + { + "type": "start", + "named": false + }, + { + "type": "string", + "named": true + }, + { + "type": "struct", + "named": false + }, + { + "type": "structref", + "named": false + }, + { + "type": "sub", + "named": false + }, + { + "type": "switch", + "named": false + }, + { + "type": "table", + "named": false + }, + { + "type": "tag", + "named": false + }, + { + "type": "then", + "named": false + }, + { + "type": "try_table", + "named": false + }, + { + "type": "type", + "named": false + }, + { + "type": "uinteger", + "named": true + }, + { + "type": "unshared", + "named": false + }, + { + "type": "vec_type", + "named": true + } +] \ No newline at end of file diff --git a/vendor/tree-sitter-wat/src/parser.c b/vendor/tree-sitter-wat/src/parser.c new file mode 100644 index 0000000..6eefc9c --- /dev/null +++ b/vendor/tree-sitter-wat/src/parser.c @@ -0,0 +1,70470 @@ +/* Automatically @generated by tree-sitter */ + +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#ifdef _MSC_VER +#pragma optimize("", off) +#elif defined(__clang__) +#pragma clang optimize off +#elif defined(__GNUC__) +#pragma GCC optimize ("O0") +#endif + +#define LANGUAGE_VERSION 15 +#define STATE_COUNT 1641 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 200 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 100 +#define EXTERNAL_TOKEN_COUNT 1 +#define FIELD_COUNT 2 +#define MAX_ALIAS_SEQUENCE_LENGTH 11 +#define MAX_RESERVED_WORD_SET_SIZE 0 +#define PRODUCTION_ID_COUNT 10 +#define SUPERTYPE_COUNT 0 + +enum ts_symbol_identifiers { + anon_sym_i32 = 1, + anon_sym_i64 = 2, + anon_sym_LPAREN = 3, + anon_sym_array = 4, + anon_sym_RPAREN = 5, + anon_sym_block = 6, + anon_sym_end = 7, + anon_sym_if = 8, + anon_sym_else = 9, + anon_sym_then = 10, + anon_sym_loop = 11, + anon_sym_try_table = 12, + anon_sym_call_indirect = 13, + anon_sym_return_call_indirect = 14, + anon_sym_catch = 15, + anon_sym_catch_ref = 16, + anon_sym_catch_all = 17, + anon_sym_catch_all_ref = 18, + anon_sym_cont = 19, + anon_sym_data = 20, + anon_sym_elem = 21, + anon_sym_item = 22, + anon_sym_func = 23, + anon_sym_export = 24, + anon_sym_global = 25, + anon_sym_table = 26, + anon_sym_memory = 27, + anon_sym_tag = 28, + anon_sym_field = 29, + anon_sym_mut = 30, + anon_sym_any = 31, + anon_sym_eq = 32, + anon_sym_i31 = 33, + anon_sym_struct = 34, + anon_sym_none = 35, + anon_sym_nofunc = 36, + anon_sym_exn = 37, + anon_sym_noexn = 38, + anon_sym_extern = 39, + anon_sym_noextern = 40, + anon_sym_nocont = 41, + anon_sym_import = 42, + anon_sym_local = 43, + anon_sym_pagesize = 44, + anon_sym_module = 45, + anon_sym_declare = 46, + anon_sym_start = 47, + anon_sym_f32 = 48, + anon_sym_f64 = 49, + anon_sym_offset = 50, + anon_sym_on = 51, + anon_sym_switch = 52, + anon_sym_i8 = 53, + anon_sym_i16 = 54, + anon_sym_param = 55, + anon_sym_rec = 56, + anon_sym_anyref = 57, + anon_sym_eqref = 58, + anon_sym_i31ref = 59, + anon_sym_structref = 60, + anon_sym_arrayref = 61, + anon_sym_nullref = 62, + anon_sym_funcref = 63, + anon_sym_nullfuncref = 64, + anon_sym_exnref = 65, + anon_sym_nullexnref = 66, + anon_sym_externref = 67, + anon_sym_nullexternref = 68, + anon_sym_contref = 69, + anon_sym_nullcontref = 70, + anon_sym_ref = 71, + anon_sym_null = 72, + anon_sym_result = 73, + anon_sym_sub = 74, + anon_sym_final = 75, + anon_sym_type = 76, + sym_vec_type = 77, + sym_identifier = 78, + sym_instr_name = 79, + sym_integer = 80, + aux_sym_float_token1 = 81, + aux_sym_float_token2 = 82, + sym_mem_arg = 83, + anon_sym_i8x16 = 84, + anon_sym_i16x8 = 85, + anon_sym_i32x4 = 86, + anon_sym_i64x2 = 87, + anon_sym_f32x4 = 88, + anon_sym_f64x2 = 89, + anon_sym_shared = 90, + anon_sym_unshared = 91, + sym_string = 92, + sym_uinteger = 93, + sym_annotation_start = 94, + sym_annotation_elem = 95, + anon_sym_LPAREN_SEMI = 96, + anon_sym_SEMI_RPAREN = 97, + sym_line_comment = 98, + sym__block_comment_content = 99, + sym_root = 100, + sym_addr_type = 101, + sym_array_type = 102, + sym_block_block = 103, + sym__block_block_folded = 104, + sym_block_if = 105, + sym__block_if_folded = 106, + sym_block_if_else = 107, + sym__block_if_else_folded = 108, + sym_block_if_then = 109, + sym__block_if_then_folded = 110, + sym_block_loop = 111, + sym__block_loop_folded = 112, + sym_block_try_table = 113, + sym__block_try_table_folded = 114, + sym__call_indirect = 115, + sym__call_indirect_folded = 116, + sym_catch = 117, + sym__composite_type = 118, + sym_cont_type = 119, + sym_data = 120, + sym_elem = 121, + sym_elem_expr = 122, + sym_elem_list = 123, + sym_export = 124, + sym_extern_idx = 125, + sym__extern_type = 126, + sym_extern_type_func = 127, + sym_extern_type_global = 128, + sym_extern_type_memory = 129, + sym_extern_type_table = 130, + sym_extern_type_tag = 131, + sym_field = 132, + sym_field_type = 133, + sym_func_type = 134, + sym_global_type = 135, + sym_heap_type = 136, + sym__immediate = 137, + sym_import = 138, + sym_index = 139, + sym__instr = 140, + sym__instr_folded = 141, + sym_local = 142, + sym_mem_page_size = 143, + sym_mem_type = 144, + sym_mem_use = 145, + sym_module = 146, + sym__module_field = 147, + sym_module_field_data = 148, + sym_module_field_elem = 149, + sym_module_field_export = 150, + sym_module_field_func = 151, + sym_module_field_global = 152, + sym_module_field_import = 153, + sym_module_field_memory = 154, + sym_module_field_start = 155, + sym_module_field_table = 156, + sym_module_field_tag = 157, + sym_num_type = 158, + sym_offset = 159, + sym_on_clause = 160, + sym_packed_type = 161, + sym_param = 162, + sym_plain_instr = 163, + sym__plain_instr_folded = 164, + sym_rec_type = 165, + sym_ref_type = 166, + sym_result = 167, + sym__storage_type = 168, + sym_struct_type = 169, + sym_sub_type = 170, + sym_table_type = 171, + sym_table_use = 172, + sym_type_def = 173, + sym_type_use = 174, + sym__value_type = 175, + sym_float = 176, + sym_shape_descriptor = 177, + sym_share = 178, + sym__annotation = 179, + sym_annotation_end = 180, + sym_block_comment = 181, + aux_sym_root_repeat1 = 182, + aux_sym_root_repeat2 = 183, + aux_sym_block_block_repeat1 = 184, + aux_sym_block_block_repeat2 = 185, + aux_sym_block_block_repeat3 = 186, + aux_sym_block_try_table_repeat1 = 187, + aux_sym__call_indirect_folded_repeat1 = 188, + aux_sym_data_repeat1 = 189, + aux_sym_elem_repeat1 = 190, + aux_sym_elem_repeat2 = 191, + aux_sym_field_repeat1 = 192, + aux_sym_local_repeat1 = 193, + aux_sym_module_field_func_repeat1 = 194, + aux_sym_module_field_func_repeat2 = 195, + aux_sym_plain_instr_repeat1 = 196, + aux_sym_rec_type_repeat1 = 197, + aux_sym_struct_type_repeat1 = 198, + aux_sym__annotation_repeat1 = 199, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_i32] = "i32", + [anon_sym_i64] = "i64", + [anon_sym_LPAREN] = "(", + [anon_sym_array] = "array", + [anon_sym_RPAREN] = ")", + [anon_sym_block] = "block", + [anon_sym_end] = "end", + [anon_sym_if] = "if", + [anon_sym_else] = "else", + [anon_sym_then] = "then", + [anon_sym_loop] = "loop", + [anon_sym_try_table] = "try_table", + [anon_sym_call_indirect] = "instr_name", + [anon_sym_return_call_indirect] = "instr_name", + [anon_sym_catch] = "catch", + [anon_sym_catch_ref] = "catch_ref", + [anon_sym_catch_all] = "catch_all", + [anon_sym_catch_all_ref] = "catch_all_ref", + [anon_sym_cont] = "cont", + [anon_sym_data] = "data", + [anon_sym_elem] = "elem", + [anon_sym_item] = "item", + [anon_sym_func] = "func", + [anon_sym_export] = "export", + [anon_sym_global] = "global", + [anon_sym_table] = "table", + [anon_sym_memory] = "memory", + [anon_sym_tag] = "tag", + [anon_sym_field] = "field", + [anon_sym_mut] = "mut", + [anon_sym_any] = "any", + [anon_sym_eq] = "eq", + [anon_sym_i31] = "i31", + [anon_sym_struct] = "struct", + [anon_sym_none] = "none", + [anon_sym_nofunc] = "nofunc", + [anon_sym_exn] = "exn", + [anon_sym_noexn] = "noexn", + [anon_sym_extern] = "extern", + [anon_sym_noextern] = "noextern", + [anon_sym_nocont] = "nocont", + [anon_sym_import] = "import", + [anon_sym_local] = "local", + [anon_sym_pagesize] = "pagesize", + [anon_sym_module] = "module", + [anon_sym_declare] = "declare", + [anon_sym_start] = "start", + [anon_sym_f32] = "f32", + [anon_sym_f64] = "f64", + [anon_sym_offset] = "offset", + [anon_sym_on] = "on", + [anon_sym_switch] = "switch", + [anon_sym_i8] = "i8", + [anon_sym_i16] = "i16", + [anon_sym_param] = "param", + [anon_sym_rec] = "rec", + [anon_sym_anyref] = "anyref", + [anon_sym_eqref] = "eqref", + [anon_sym_i31ref] = "i31ref", + [anon_sym_structref] = "structref", + [anon_sym_arrayref] = "arrayref", + [anon_sym_nullref] = "nullref", + [anon_sym_funcref] = "funcref", + [anon_sym_nullfuncref] = "nullfuncref", + [anon_sym_exnref] = "exnref", + [anon_sym_nullexnref] = "nullexnref", + [anon_sym_externref] = "externref", + [anon_sym_nullexternref] = "nullexternref", + [anon_sym_contref] = "contref", + [anon_sym_nullcontref] = "nullcontref", + [anon_sym_ref] = "ref", + [anon_sym_null] = "null", + [anon_sym_result] = "result", + [anon_sym_sub] = "sub", + [anon_sym_final] = "final", + [anon_sym_type] = "type", + [sym_vec_type] = "vec_type", + [sym_identifier] = "identifier", + [sym_instr_name] = "instr_name", + [sym_integer] = "integer", + [aux_sym_float_token1] = "float_token1", + [aux_sym_float_token2] = "float_token2", + [sym_mem_arg] = "mem_arg", + [anon_sym_i8x16] = "i8x16", + [anon_sym_i16x8] = "i16x8", + [anon_sym_i32x4] = "i32x4", + [anon_sym_i64x2] = "i64x2", + [anon_sym_f32x4] = "f32x4", + [anon_sym_f64x2] = "f64x2", + [anon_sym_shared] = "shared", + [anon_sym_unshared] = "unshared", + [sym_string] = "string", + [sym_uinteger] = "uinteger", + [sym_annotation_start] = "annotation_start", + [sym_annotation_elem] = "annotation_elem", + [anon_sym_LPAREN_SEMI] = "(;", + [anon_sym_SEMI_RPAREN] = ";)", + [sym_line_comment] = "line_comment", + [sym__block_comment_content] = "_block_comment_content", + [sym_root] = "root", + [sym_addr_type] = "addr_type", + [sym_array_type] = "array_type", + [sym_block_block] = "block_block", + [sym__block_block_folded] = "_block_block_folded", + [sym_block_if] = "block_if", + [sym__block_if_folded] = "_block_if_folded", + [sym_block_if_else] = "block_if_else", + [sym__block_if_else_folded] = "block_if_else", + [sym_block_if_then] = "block_if_then", + [sym__block_if_then_folded] = "block_if_then", + [sym_block_loop] = "block_loop", + [sym__block_loop_folded] = "_block_loop_folded", + [sym_block_try_table] = "block_try_table", + [sym__block_try_table_folded] = "_block_try_table_folded", + [sym__call_indirect] = "plain_instr", + [sym__call_indirect_folded] = "_call_indirect_folded", + [sym_catch] = "catch", + [sym__composite_type] = "_composite_type", + [sym_cont_type] = "cont_type", + [sym_data] = "data", + [sym_elem] = "elem", + [sym_elem_expr] = "elem_expr", + [sym_elem_list] = "elem_list", + [sym_export] = "export", + [sym_extern_idx] = "extern_idx", + [sym__extern_type] = "_extern_type", + [sym_extern_type_func] = "extern_type_func", + [sym_extern_type_global] = "extern_type_global", + [sym_extern_type_memory] = "extern_type_memory", + [sym_extern_type_table] = "extern_type_table", + [sym_extern_type_tag] = "extern_type_tag", + [sym_field] = "field", + [sym_field_type] = "field_type", + [sym_func_type] = "func_type", + [sym_global_type] = "global_type", + [sym_heap_type] = "heap_type", + [sym__immediate] = "_immediate", + [sym_import] = "import", + [sym_index] = "index", + [sym__instr] = "_instr", + [sym__instr_folded] = "_instr_folded", + [sym_local] = "local", + [sym_mem_page_size] = "mem_page_size", + [sym_mem_type] = "mem_type", + [sym_mem_use] = "mem_use", + [sym_module] = "module", + [sym__module_field] = "_module_field", + [sym_module_field_data] = "module_field_data", + [sym_module_field_elem] = "module_field_elem", + [sym_module_field_export] = "module_field_export", + [sym_module_field_func] = "module_field_func", + [sym_module_field_global] = "module_field_global", + [sym_module_field_import] = "module_field_import", + [sym_module_field_memory] = "module_field_memory", + [sym_module_field_start] = "module_field_start", + [sym_module_field_table] = "module_field_table", + [sym_module_field_tag] = "module_field_tag", + [sym_num_type] = "num_type", + [sym_offset] = "offset", + [sym_on_clause] = "on_clause", + [sym_packed_type] = "packed_type", + [sym_param] = "param", + [sym_plain_instr] = "plain_instr", + [sym__plain_instr_folded] = "_plain_instr_folded", + [sym_rec_type] = "rec_type", + [sym_ref_type] = "ref_type", + [sym_result] = "result", + [sym__storage_type] = "_storage_type", + [sym_struct_type] = "struct_type", + [sym_sub_type] = "sub_type", + [sym_table_type] = "table_type", + [sym_table_use] = "table_use", + [sym_type_def] = "type_def", + [sym_type_use] = "type_use", + [sym__value_type] = "_value_type", + [sym_float] = "float", + [sym_shape_descriptor] = "shape_descriptor", + [sym_share] = "share", + [sym__annotation] = "_annotation", + [sym_annotation_end] = "annotation_end", + [sym_block_comment] = "block_comment", + [aux_sym_root_repeat1] = "root_repeat1", + [aux_sym_root_repeat2] = "root_repeat2", + [aux_sym_block_block_repeat1] = "block_block_repeat1", + [aux_sym_block_block_repeat2] = "block_block_repeat2", + [aux_sym_block_block_repeat3] = "block_block_repeat3", + [aux_sym_block_try_table_repeat1] = "block_try_table_repeat1", + [aux_sym__call_indirect_folded_repeat1] = "_call_indirect_folded_repeat1", + [aux_sym_data_repeat1] = "data_repeat1", + [aux_sym_elem_repeat1] = "elem_repeat1", + [aux_sym_elem_repeat2] = "elem_repeat2", + [aux_sym_field_repeat1] = "field_repeat1", + [aux_sym_local_repeat1] = "local_repeat1", + [aux_sym_module_field_func_repeat1] = "module_field_func_repeat1", + [aux_sym_module_field_func_repeat2] = "module_field_func_repeat2", + [aux_sym_plain_instr_repeat1] = "plain_instr_repeat1", + [aux_sym_rec_type_repeat1] = "rec_type_repeat1", + [aux_sym_struct_type_repeat1] = "struct_type_repeat1", + [aux_sym__annotation_repeat1] = "_annotation_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_i32] = anon_sym_i32, + [anon_sym_i64] = anon_sym_i64, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_array] = anon_sym_array, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_block] = anon_sym_block, + [anon_sym_end] = anon_sym_end, + [anon_sym_if] = anon_sym_if, + [anon_sym_else] = anon_sym_else, + [anon_sym_then] = anon_sym_then, + [anon_sym_loop] = anon_sym_loop, + [anon_sym_try_table] = anon_sym_try_table, + [anon_sym_call_indirect] = sym_instr_name, + [anon_sym_return_call_indirect] = sym_instr_name, + [anon_sym_catch] = anon_sym_catch, + [anon_sym_catch_ref] = anon_sym_catch_ref, + [anon_sym_catch_all] = anon_sym_catch_all, + [anon_sym_catch_all_ref] = anon_sym_catch_all_ref, + [anon_sym_cont] = anon_sym_cont, + [anon_sym_data] = anon_sym_data, + [anon_sym_elem] = anon_sym_elem, + [anon_sym_item] = anon_sym_item, + [anon_sym_func] = anon_sym_func, + [anon_sym_export] = anon_sym_export, + [anon_sym_global] = anon_sym_global, + [anon_sym_table] = anon_sym_table, + [anon_sym_memory] = anon_sym_memory, + [anon_sym_tag] = anon_sym_tag, + [anon_sym_field] = anon_sym_field, + [anon_sym_mut] = anon_sym_mut, + [anon_sym_any] = anon_sym_any, + [anon_sym_eq] = anon_sym_eq, + [anon_sym_i31] = anon_sym_i31, + [anon_sym_struct] = anon_sym_struct, + [anon_sym_none] = anon_sym_none, + [anon_sym_nofunc] = anon_sym_nofunc, + [anon_sym_exn] = anon_sym_exn, + [anon_sym_noexn] = anon_sym_noexn, + [anon_sym_extern] = anon_sym_extern, + [anon_sym_noextern] = anon_sym_noextern, + [anon_sym_nocont] = anon_sym_nocont, + [anon_sym_import] = anon_sym_import, + [anon_sym_local] = anon_sym_local, + [anon_sym_pagesize] = anon_sym_pagesize, + [anon_sym_module] = anon_sym_module, + [anon_sym_declare] = anon_sym_declare, + [anon_sym_start] = anon_sym_start, + [anon_sym_f32] = anon_sym_f32, + [anon_sym_f64] = anon_sym_f64, + [anon_sym_offset] = anon_sym_offset, + [anon_sym_on] = anon_sym_on, + [anon_sym_switch] = anon_sym_switch, + [anon_sym_i8] = anon_sym_i8, + [anon_sym_i16] = anon_sym_i16, + [anon_sym_param] = anon_sym_param, + [anon_sym_rec] = anon_sym_rec, + [anon_sym_anyref] = anon_sym_anyref, + [anon_sym_eqref] = anon_sym_eqref, + [anon_sym_i31ref] = anon_sym_i31ref, + [anon_sym_structref] = anon_sym_structref, + [anon_sym_arrayref] = anon_sym_arrayref, + [anon_sym_nullref] = anon_sym_nullref, + [anon_sym_funcref] = anon_sym_funcref, + [anon_sym_nullfuncref] = anon_sym_nullfuncref, + [anon_sym_exnref] = anon_sym_exnref, + [anon_sym_nullexnref] = anon_sym_nullexnref, + [anon_sym_externref] = anon_sym_externref, + [anon_sym_nullexternref] = anon_sym_nullexternref, + [anon_sym_contref] = anon_sym_contref, + [anon_sym_nullcontref] = anon_sym_nullcontref, + [anon_sym_ref] = anon_sym_ref, + [anon_sym_null] = anon_sym_null, + [anon_sym_result] = anon_sym_result, + [anon_sym_sub] = anon_sym_sub, + [anon_sym_final] = anon_sym_final, + [anon_sym_type] = anon_sym_type, + [sym_vec_type] = sym_vec_type, + [sym_identifier] = sym_identifier, + [sym_instr_name] = sym_instr_name, + [sym_integer] = sym_integer, + [aux_sym_float_token1] = aux_sym_float_token1, + [aux_sym_float_token2] = aux_sym_float_token2, + [sym_mem_arg] = sym_mem_arg, + [anon_sym_i8x16] = anon_sym_i8x16, + [anon_sym_i16x8] = anon_sym_i16x8, + [anon_sym_i32x4] = anon_sym_i32x4, + [anon_sym_i64x2] = anon_sym_i64x2, + [anon_sym_f32x4] = anon_sym_f32x4, + [anon_sym_f64x2] = anon_sym_f64x2, + [anon_sym_shared] = anon_sym_shared, + [anon_sym_unshared] = anon_sym_unshared, + [sym_string] = sym_string, + [sym_uinteger] = sym_uinteger, + [sym_annotation_start] = sym_annotation_start, + [sym_annotation_elem] = sym_annotation_elem, + [anon_sym_LPAREN_SEMI] = anon_sym_LPAREN_SEMI, + [anon_sym_SEMI_RPAREN] = anon_sym_SEMI_RPAREN, + [sym_line_comment] = sym_line_comment, + [sym__block_comment_content] = sym__block_comment_content, + [sym_root] = sym_root, + [sym_addr_type] = sym_addr_type, + [sym_array_type] = sym_array_type, + [sym_block_block] = sym_block_block, + [sym__block_block_folded] = sym__block_block_folded, + [sym_block_if] = sym_block_if, + [sym__block_if_folded] = sym__block_if_folded, + [sym_block_if_else] = sym_block_if_else, + [sym__block_if_else_folded] = sym_block_if_else, + [sym_block_if_then] = sym_block_if_then, + [sym__block_if_then_folded] = sym_block_if_then, + [sym_block_loop] = sym_block_loop, + [sym__block_loop_folded] = sym__block_loop_folded, + [sym_block_try_table] = sym_block_try_table, + [sym__block_try_table_folded] = sym__block_try_table_folded, + [sym__call_indirect] = sym_plain_instr, + [sym__call_indirect_folded] = sym__call_indirect_folded, + [sym_catch] = sym_catch, + [sym__composite_type] = sym__composite_type, + [sym_cont_type] = sym_cont_type, + [sym_data] = sym_data, + [sym_elem] = sym_elem, + [sym_elem_expr] = sym_elem_expr, + [sym_elem_list] = sym_elem_list, + [sym_export] = sym_export, + [sym_extern_idx] = sym_extern_idx, + [sym__extern_type] = sym__extern_type, + [sym_extern_type_func] = sym_extern_type_func, + [sym_extern_type_global] = sym_extern_type_global, + [sym_extern_type_memory] = sym_extern_type_memory, + [sym_extern_type_table] = sym_extern_type_table, + [sym_extern_type_tag] = sym_extern_type_tag, + [sym_field] = sym_field, + [sym_field_type] = sym_field_type, + [sym_func_type] = sym_func_type, + [sym_global_type] = sym_global_type, + [sym_heap_type] = sym_heap_type, + [sym__immediate] = sym__immediate, + [sym_import] = sym_import, + [sym_index] = sym_index, + [sym__instr] = sym__instr, + [sym__instr_folded] = sym__instr_folded, + [sym_local] = sym_local, + [sym_mem_page_size] = sym_mem_page_size, + [sym_mem_type] = sym_mem_type, + [sym_mem_use] = sym_mem_use, + [sym_module] = sym_module, + [sym__module_field] = sym__module_field, + [sym_module_field_data] = sym_module_field_data, + [sym_module_field_elem] = sym_module_field_elem, + [sym_module_field_export] = sym_module_field_export, + [sym_module_field_func] = sym_module_field_func, + [sym_module_field_global] = sym_module_field_global, + [sym_module_field_import] = sym_module_field_import, + [sym_module_field_memory] = sym_module_field_memory, + [sym_module_field_start] = sym_module_field_start, + [sym_module_field_table] = sym_module_field_table, + [sym_module_field_tag] = sym_module_field_tag, + [sym_num_type] = sym_num_type, + [sym_offset] = sym_offset, + [sym_on_clause] = sym_on_clause, + [sym_packed_type] = sym_packed_type, + [sym_param] = sym_param, + [sym_plain_instr] = sym_plain_instr, + [sym__plain_instr_folded] = sym__plain_instr_folded, + [sym_rec_type] = sym_rec_type, + [sym_ref_type] = sym_ref_type, + [sym_result] = sym_result, + [sym__storage_type] = sym__storage_type, + [sym_struct_type] = sym_struct_type, + [sym_sub_type] = sym_sub_type, + [sym_table_type] = sym_table_type, + [sym_table_use] = sym_table_use, + [sym_type_def] = sym_type_def, + [sym_type_use] = sym_type_use, + [sym__value_type] = sym__value_type, + [sym_float] = sym_float, + [sym_shape_descriptor] = sym_shape_descriptor, + [sym_share] = sym_share, + [sym__annotation] = sym__annotation, + [sym_annotation_end] = sym_annotation_end, + [sym_block_comment] = sym_block_comment, + [aux_sym_root_repeat1] = aux_sym_root_repeat1, + [aux_sym_root_repeat2] = aux_sym_root_repeat2, + [aux_sym_block_block_repeat1] = aux_sym_block_block_repeat1, + [aux_sym_block_block_repeat2] = aux_sym_block_block_repeat2, + [aux_sym_block_block_repeat3] = aux_sym_block_block_repeat3, + [aux_sym_block_try_table_repeat1] = aux_sym_block_try_table_repeat1, + [aux_sym__call_indirect_folded_repeat1] = aux_sym__call_indirect_folded_repeat1, + [aux_sym_data_repeat1] = aux_sym_data_repeat1, + [aux_sym_elem_repeat1] = aux_sym_elem_repeat1, + [aux_sym_elem_repeat2] = aux_sym_elem_repeat2, + [aux_sym_field_repeat1] = aux_sym_field_repeat1, + [aux_sym_local_repeat1] = aux_sym_local_repeat1, + [aux_sym_module_field_func_repeat1] = aux_sym_module_field_func_repeat1, + [aux_sym_module_field_func_repeat2] = aux_sym_module_field_func_repeat2, + [aux_sym_plain_instr_repeat1] = aux_sym_plain_instr_repeat1, + [aux_sym_rec_type_repeat1] = aux_sym_rec_type_repeat1, + [aux_sym_struct_type_repeat1] = aux_sym_struct_type_repeat1, + [aux_sym__annotation_repeat1] = aux_sym__annotation_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_i32] = { + .visible = true, + .named = false, + }, + [anon_sym_i64] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_array] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_block] = { + .visible = true, + .named = false, + }, + [anon_sym_end] = { + .visible = true, + .named = false, + }, + [anon_sym_if] = { + .visible = true, + .named = false, + }, + [anon_sym_else] = { + .visible = true, + .named = false, + }, + [anon_sym_then] = { + .visible = true, + .named = false, + }, + [anon_sym_loop] = { + .visible = true, + .named = false, + }, + [anon_sym_try_table] = { + .visible = true, + .named = false, + }, + [anon_sym_call_indirect] = { + .visible = true, + .named = true, + }, + [anon_sym_return_call_indirect] = { + .visible = true, + .named = true, + }, + [anon_sym_catch] = { + .visible = true, + .named = false, + }, + [anon_sym_catch_ref] = { + .visible = true, + .named = false, + }, + [anon_sym_catch_all] = { + .visible = true, + .named = false, + }, + [anon_sym_catch_all_ref] = { + .visible = true, + .named = false, + }, + [anon_sym_cont] = { + .visible = true, + .named = false, + }, + [anon_sym_data] = { + .visible = true, + .named = false, + }, + [anon_sym_elem] = { + .visible = true, + .named = false, + }, + [anon_sym_item] = { + .visible = true, + .named = false, + }, + [anon_sym_func] = { + .visible = true, + .named = false, + }, + [anon_sym_export] = { + .visible = true, + .named = false, + }, + [anon_sym_global] = { + .visible = true, + .named = false, + }, + [anon_sym_table] = { + .visible = true, + .named = false, + }, + [anon_sym_memory] = { + .visible = true, + .named = false, + }, + [anon_sym_tag] = { + .visible = true, + .named = false, + }, + [anon_sym_field] = { + .visible = true, + .named = false, + }, + [anon_sym_mut] = { + .visible = true, + .named = false, + }, + [anon_sym_any] = { + .visible = true, + .named = false, + }, + [anon_sym_eq] = { + .visible = true, + .named = false, + }, + [anon_sym_i31] = { + .visible = true, + .named = false, + }, + [anon_sym_struct] = { + .visible = true, + .named = false, + }, + [anon_sym_none] = { + .visible = true, + .named = false, + }, + [anon_sym_nofunc] = { + .visible = true, + .named = false, + }, + [anon_sym_exn] = { + .visible = true, + .named = false, + }, + [anon_sym_noexn] = { + .visible = true, + .named = false, + }, + [anon_sym_extern] = { + .visible = true, + .named = false, + }, + [anon_sym_noextern] = { + .visible = true, + .named = false, + }, + [anon_sym_nocont] = { + .visible = true, + .named = false, + }, + [anon_sym_import] = { + .visible = true, + .named = false, + }, + [anon_sym_local] = { + .visible = true, + .named = false, + }, + [anon_sym_pagesize] = { + .visible = true, + .named = false, + }, + [anon_sym_module] = { + .visible = true, + .named = false, + }, + [anon_sym_declare] = { + .visible = true, + .named = false, + }, + [anon_sym_start] = { + .visible = true, + .named = false, + }, + [anon_sym_f32] = { + .visible = true, + .named = false, + }, + [anon_sym_f64] = { + .visible = true, + .named = false, + }, + [anon_sym_offset] = { + .visible = true, + .named = false, + }, + [anon_sym_on] = { + .visible = true, + .named = false, + }, + [anon_sym_switch] = { + .visible = true, + .named = false, + }, + [anon_sym_i8] = { + .visible = true, + .named = false, + }, + [anon_sym_i16] = { + .visible = true, + .named = false, + }, + [anon_sym_param] = { + .visible = true, + .named = false, + }, + [anon_sym_rec] = { + .visible = true, + .named = false, + }, + [anon_sym_anyref] = { + .visible = true, + .named = false, + }, + [anon_sym_eqref] = { + .visible = true, + .named = false, + }, + [anon_sym_i31ref] = { + .visible = true, + .named = false, + }, + [anon_sym_structref] = { + .visible = true, + .named = false, + }, + [anon_sym_arrayref] = { + .visible = true, + .named = false, + }, + [anon_sym_nullref] = { + .visible = true, + .named = false, + }, + [anon_sym_funcref] = { + .visible = true, + .named = false, + }, + [anon_sym_nullfuncref] = { + .visible = true, + .named = false, + }, + [anon_sym_exnref] = { + .visible = true, + .named = false, + }, + [anon_sym_nullexnref] = { + .visible = true, + .named = false, + }, + [anon_sym_externref] = { + .visible = true, + .named = false, + }, + [anon_sym_nullexternref] = { + .visible = true, + .named = false, + }, + [anon_sym_contref] = { + .visible = true, + .named = false, + }, + [anon_sym_nullcontref] = { + .visible = true, + .named = false, + }, + [anon_sym_ref] = { + .visible = true, + .named = false, + }, + [anon_sym_null] = { + .visible = true, + .named = false, + }, + [anon_sym_result] = { + .visible = true, + .named = false, + }, + [anon_sym_sub] = { + .visible = true, + .named = false, + }, + [anon_sym_final] = { + .visible = true, + .named = false, + }, + [anon_sym_type] = { + .visible = true, + .named = false, + }, + [sym_vec_type] = { + .visible = true, + .named = true, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [sym_instr_name] = { + .visible = true, + .named = true, + }, + [sym_integer] = { + .visible = true, + .named = true, + }, + [aux_sym_float_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_float_token2] = { + .visible = false, + .named = false, + }, + [sym_mem_arg] = { + .visible = true, + .named = true, + }, + [anon_sym_i8x16] = { + .visible = true, + .named = false, + }, + [anon_sym_i16x8] = { + .visible = true, + .named = false, + }, + [anon_sym_i32x4] = { + .visible = true, + .named = false, + }, + [anon_sym_i64x2] = { + .visible = true, + .named = false, + }, + [anon_sym_f32x4] = { + .visible = true, + .named = false, + }, + [anon_sym_f64x2] = { + .visible = true, + .named = false, + }, + [anon_sym_shared] = { + .visible = true, + .named = false, + }, + [anon_sym_unshared] = { + .visible = true, + .named = false, + }, + [sym_string] = { + .visible = true, + .named = true, + }, + [sym_uinteger] = { + .visible = true, + .named = true, + }, + [sym_annotation_start] = { + .visible = true, + .named = true, + }, + [sym_annotation_elem] = { + .visible = true, + .named = true, + }, + [anon_sym_LPAREN_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI_RPAREN] = { + .visible = true, + .named = false, + }, + [sym_line_comment] = { + .visible = true, + .named = true, + }, + [sym__block_comment_content] = { + .visible = false, + .named = true, + }, + [sym_root] = { + .visible = true, + .named = true, + }, + [sym_addr_type] = { + .visible = true, + .named = true, + }, + [sym_array_type] = { + .visible = true, + .named = true, + }, + [sym_block_block] = { + .visible = true, + .named = true, + }, + [sym__block_block_folded] = { + .visible = false, + .named = true, + }, + [sym_block_if] = { + .visible = true, + .named = true, + }, + [sym__block_if_folded] = { + .visible = false, + .named = true, + }, + [sym_block_if_else] = { + .visible = true, + .named = true, + }, + [sym__block_if_else_folded] = { + .visible = true, + .named = true, + }, + [sym_block_if_then] = { + .visible = true, + .named = true, + }, + [sym__block_if_then_folded] = { + .visible = true, + .named = true, + }, + [sym_block_loop] = { + .visible = true, + .named = true, + }, + [sym__block_loop_folded] = { + .visible = false, + .named = true, + }, + [sym_block_try_table] = { + .visible = true, + .named = true, + }, + [sym__block_try_table_folded] = { + .visible = false, + .named = true, + }, + [sym__call_indirect] = { + .visible = true, + .named = true, + }, + [sym__call_indirect_folded] = { + .visible = false, + .named = true, + }, + [sym_catch] = { + .visible = true, + .named = true, + }, + [sym__composite_type] = { + .visible = false, + .named = true, + }, + [sym_cont_type] = { + .visible = true, + .named = true, + }, + [sym_data] = { + .visible = true, + .named = true, + }, + [sym_elem] = { + .visible = true, + .named = true, + }, + [sym_elem_expr] = { + .visible = true, + .named = true, + }, + [sym_elem_list] = { + .visible = true, + .named = true, + }, + [sym_export] = { + .visible = true, + .named = true, + }, + [sym_extern_idx] = { + .visible = true, + .named = true, + }, + [sym__extern_type] = { + .visible = false, + .named = true, + }, + [sym_extern_type_func] = { + .visible = true, + .named = true, + }, + [sym_extern_type_global] = { + .visible = true, + .named = true, + }, + [sym_extern_type_memory] = { + .visible = true, + .named = true, + }, + [sym_extern_type_table] = { + .visible = true, + .named = true, + }, + [sym_extern_type_tag] = { + .visible = true, + .named = true, + }, + [sym_field] = { + .visible = true, + .named = true, + }, + [sym_field_type] = { + .visible = true, + .named = true, + }, + [sym_func_type] = { + .visible = true, + .named = true, + }, + [sym_global_type] = { + .visible = true, + .named = true, + }, + [sym_heap_type] = { + .visible = true, + .named = true, + }, + [sym__immediate] = { + .visible = false, + .named = true, + }, + [sym_import] = { + .visible = true, + .named = true, + }, + [sym_index] = { + .visible = true, + .named = true, + }, + [sym__instr] = { + .visible = false, + .named = true, + }, + [sym__instr_folded] = { + .visible = false, + .named = true, + }, + [sym_local] = { + .visible = true, + .named = true, + }, + [sym_mem_page_size] = { + .visible = true, + .named = true, + }, + [sym_mem_type] = { + .visible = true, + .named = true, + }, + [sym_mem_use] = { + .visible = true, + .named = true, + }, + [sym_module] = { + .visible = true, + .named = true, + }, + [sym__module_field] = { + .visible = false, + .named = true, + }, + [sym_module_field_data] = { + .visible = true, + .named = true, + }, + [sym_module_field_elem] = { + .visible = true, + .named = true, + }, + [sym_module_field_export] = { + .visible = true, + .named = true, + }, + [sym_module_field_func] = { + .visible = true, + .named = true, + }, + [sym_module_field_global] = { + .visible = true, + .named = true, + }, + [sym_module_field_import] = { + .visible = true, + .named = true, + }, + [sym_module_field_memory] = { + .visible = true, + .named = true, + }, + [sym_module_field_start] = { + .visible = true, + .named = true, + }, + [sym_module_field_table] = { + .visible = true, + .named = true, + }, + [sym_module_field_tag] = { + .visible = true, + .named = true, + }, + [sym_num_type] = { + .visible = true, + .named = true, + }, + [sym_offset] = { + .visible = true, + .named = true, + }, + [sym_on_clause] = { + .visible = true, + .named = true, + }, + [sym_packed_type] = { + .visible = true, + .named = true, + }, + [sym_param] = { + .visible = true, + .named = true, + }, + [sym_plain_instr] = { + .visible = true, + .named = true, + }, + [sym__plain_instr_folded] = { + .visible = false, + .named = true, + }, + [sym_rec_type] = { + .visible = true, + .named = true, + }, + [sym_ref_type] = { + .visible = true, + .named = true, + }, + [sym_result] = { + .visible = true, + .named = true, + }, + [sym__storage_type] = { + .visible = false, + .named = true, + }, + [sym_struct_type] = { + .visible = true, + .named = true, + }, + [sym_sub_type] = { + .visible = true, + .named = true, + }, + [sym_table_type] = { + .visible = true, + .named = true, + }, + [sym_table_use] = { + .visible = true, + .named = true, + }, + [sym_type_def] = { + .visible = true, + .named = true, + }, + [sym_type_use] = { + .visible = true, + .named = true, + }, + [sym__value_type] = { + .visible = false, + .named = true, + }, + [sym_float] = { + .visible = true, + .named = true, + }, + [sym_shape_descriptor] = { + .visible = true, + .named = true, + }, + [sym_share] = { + .visible = true, + .named = true, + }, + [sym__annotation] = { + .visible = false, + .named = true, + }, + [sym_annotation_end] = { + .visible = true, + .named = true, + }, + [sym_block_comment] = { + .visible = true, + .named = true, + }, + [aux_sym_root_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_root_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_block_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_block_block_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_block_block_repeat3] = { + .visible = false, + .named = false, + }, + [aux_sym_block_try_table_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__call_indirect_folded_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_data_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_elem_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_elem_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_field_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_local_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_module_field_func_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_module_field_func_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_plain_instr_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_rec_type_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_struct_type_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__annotation_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum ts_field_identifiers { + field_max = 1, + field_min = 2, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_max] = "max", + [field_min] = "min", +}; + +static const TSMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [6] = {.index = 0, .length = 1}, + [7] = {.index = 1, .length = 2}, + [8] = {.index = 3, .length = 1}, + [9] = {.index = 4, .length = 2}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_min, 0}, + [1] = + {field_max, 1}, + {field_min, 0}, + [3] = + {field_min, 1}, + [4] = + {field_max, 2}, + {field_min, 1}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, + [1] = { + [0] = sym_block_block, + }, + [2] = { + [0] = sym_block_if, + }, + [3] = { + [0] = sym_block_loop, + }, + [4] = { + [0] = sym_block_try_table, + }, + [5] = { + [0] = sym_plain_instr, + }, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + sym__block_block_folded, 2, + sym__block_block_folded, + sym_block_block, + sym__block_if_folded, 2, + sym__block_if_folded, + sym_block_if, + sym__block_loop_folded, 2, + sym__block_loop_folded, + sym_block_loop, + sym__block_try_table_folded, 2, + sym__block_try_table_folded, + sym_block_try_table, + sym__call_indirect_folded, 2, + sym__call_indirect_folded, + sym_plain_instr, + sym__plain_instr_folded, 2, + sym__plain_instr_folded, + sym_plain_instr, + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 2, + [7] = 2, + [8] = 4, + [9] = 9, + [10] = 4, + [11] = 2, + [12] = 4, + [13] = 5, + [14] = 9, + [15] = 3, + [16] = 3, + [17] = 9, + [18] = 5, + [19] = 9, + [20] = 20, + [21] = 21, + [22] = 22, + [23] = 23, + [24] = 24, + [25] = 25, + [26] = 26, + [27] = 27, + [28] = 28, + [29] = 29, + [30] = 30, + [31] = 23, + [32] = 27, + [33] = 21, + [34] = 20, + [35] = 21, + [36] = 30, + [37] = 28, + [38] = 22, + [39] = 30, + [40] = 28, + [41] = 23, + [42] = 29, + [43] = 24, + [44] = 22, + [45] = 29, + [46] = 25, + [47] = 24, + [48] = 25, + [49] = 26, + [50] = 27, + [51] = 20, + [52] = 26, + [53] = 22, + [54] = 24, + [55] = 26, + [56] = 21, + [57] = 30, + [58] = 28, + [59] = 23, + [60] = 25, + [61] = 20, + [62] = 27, + [63] = 29, + [64] = 64, + [65] = 65, + [66] = 66, + [67] = 67, + [68] = 68, + [69] = 69, + [70] = 70, + [71] = 70, + [72] = 70, + [73] = 73, + [74] = 74, + [75] = 75, + [76] = 73, + [77] = 74, + [78] = 78, + [79] = 74, + [80] = 73, + [81] = 74, + [82] = 78, + [83] = 78, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 91, + [92] = 85, + [93] = 86, + [94] = 94, + [95] = 95, + [96] = 88, + [97] = 87, + [98] = 95, + [99] = 86, + [100] = 87, + [101] = 88, + [102] = 102, + [103] = 90, + [104] = 91, + [105] = 85, + [106] = 95, + [107] = 90, + [108] = 88, + [109] = 91, + [110] = 110, + [111] = 111, + [112] = 112, + [113] = 113, + [114] = 114, + [115] = 115, + [116] = 116, + [117] = 117, + [118] = 112, + [119] = 119, + [120] = 120, + [121] = 121, + [122] = 122, + [123] = 123, + [124] = 124, + [125] = 125, + [126] = 126, + [127] = 127, + [128] = 128, + [129] = 120, + [130] = 119, + [131] = 117, + [132] = 111, + [133] = 133, + [134] = 113, + [135] = 114, + [136] = 136, + [137] = 121, + [138] = 122, + [139] = 124, + [140] = 125, + [141] = 133, + [142] = 136, + [143] = 143, + [144] = 120, + [145] = 119, + [146] = 143, + [147] = 117, + [148] = 111, + [149] = 149, + [150] = 150, + [151] = 113, + [152] = 114, + [153] = 121, + [154] = 122, + [155] = 155, + [156] = 124, + [157] = 125, + [158] = 133, + [159] = 136, + [160] = 143, + [161] = 155, + [162] = 117, + [163] = 111, + [164] = 121, + [165] = 122, + [166] = 166, + [167] = 133, + [168] = 136, + [169] = 155, + [170] = 112, + [171] = 112, + [172] = 155, + [173] = 173, + [174] = 174, + [175] = 173, + [176] = 176, + [177] = 177, + [178] = 178, + [179] = 173, + [180] = 180, + [181] = 181, + [182] = 181, + [183] = 183, + [184] = 183, + [185] = 181, + [186] = 186, + [187] = 180, + [188] = 186, + [189] = 189, + [190] = 176, + [191] = 186, + [192] = 173, + [193] = 176, + [194] = 176, + [195] = 174, + [196] = 196, + [197] = 197, + [198] = 174, + [199] = 177, + [200] = 177, + [201] = 178, + [202] = 183, + [203] = 178, + [204] = 183, + [205] = 180, + [206] = 206, + [207] = 207, + [208] = 208, + [209] = 209, + [210] = 210, + [211] = 211, + [212] = 212, + [213] = 213, + [214] = 214, + [215] = 215, + [216] = 216, + [217] = 217, + [218] = 218, + [219] = 219, + [220] = 220, + [221] = 221, + [222] = 222, + [223] = 223, + [224] = 224, + [225] = 225, + [226] = 215, + [227] = 227, + [228] = 228, + [229] = 229, + [230] = 230, + [231] = 217, + [232] = 232, + [233] = 233, + [234] = 234, + [235] = 235, + [236] = 236, + [237] = 237, + [238] = 238, + [239] = 206, + [240] = 234, + [241] = 241, + [242] = 235, + [243] = 243, + [244] = 207, + [245] = 222, + [246] = 208, + [247] = 214, + [248] = 220, + [249] = 249, + [250] = 238, + [251] = 249, + [252] = 218, + [253] = 253, + [254] = 234, + [255] = 255, + [256] = 253, + [257] = 257, + [258] = 258, + [259] = 219, + [260] = 241, + [261] = 241, + [262] = 262, + [263] = 263, + [264] = 264, + [265] = 255, + [266] = 210, + [267] = 228, + [268] = 232, + [269] = 207, + [270] = 208, + [271] = 222, + [272] = 206, + [273] = 211, + [274] = 212, + [275] = 221, + [276] = 224, + [277] = 215, + [278] = 220, + [279] = 217, + [280] = 218, + [281] = 219, + [282] = 257, + [283] = 221, + [284] = 238, + [285] = 223, + [286] = 224, + [287] = 249, + [288] = 258, + [289] = 235, + [290] = 223, + [291] = 214, + [292] = 220, + [293] = 255, + [294] = 238, + [295] = 249, + [296] = 296, + [297] = 211, + [298] = 257, + [299] = 255, + [300] = 258, + [301] = 228, + [302] = 232, + [303] = 212, + [304] = 207, + [305] = 208, + [306] = 262, + [307] = 211, + [308] = 218, + [309] = 219, + [310] = 262, + [311] = 221, + [312] = 224, + [313] = 263, + [314] = 263, + [315] = 227, + [316] = 229, + [317] = 233, + [318] = 243, + [319] = 253, + [320] = 320, + [321] = 210, + [322] = 227, + [323] = 229, + [324] = 233, + [325] = 243, + [326] = 253, + [327] = 228, + [328] = 232, + [329] = 227, + [330] = 229, + [331] = 233, + [332] = 243, + [333] = 214, + [334] = 334, + [335] = 334, + [336] = 334, + [337] = 337, + [338] = 338, + [339] = 339, + [340] = 340, + [341] = 341, + [342] = 342, + [343] = 343, + [344] = 344, + [345] = 345, + [346] = 346, + [347] = 347, + [348] = 348, + [349] = 349, + [350] = 350, + [351] = 351, + [352] = 341, + [353] = 353, + [354] = 354, + [355] = 348, + [356] = 354, + [357] = 357, + [358] = 340, + [359] = 342, + [360] = 338, + [361] = 344, + [362] = 345, + [363] = 346, + [364] = 364, + [365] = 349, + [366] = 350, + [367] = 367, + [368] = 338, + [369] = 367, + [370] = 370, + [371] = 371, + [372] = 371, + [373] = 373, + [374] = 374, + [375] = 375, + [376] = 376, + [377] = 377, + [378] = 378, + [379] = 373, + [380] = 380, + [381] = 381, + [382] = 382, + [383] = 383, + [384] = 384, + [385] = 385, + [386] = 386, + [387] = 387, + [388] = 388, + [389] = 374, + [390] = 375, + [391] = 351, + [392] = 392, + [393] = 341, + [394] = 394, + [395] = 348, + [396] = 376, + [397] = 354, + [398] = 351, + [399] = 399, + [400] = 340, + [401] = 378, + [402] = 342, + [403] = 344, + [404] = 345, + [405] = 346, + [406] = 380, + [407] = 349, + [408] = 381, + [409] = 350, + [410] = 382, + [411] = 338, + [412] = 367, + [413] = 383, + [414] = 371, + [415] = 373, + [416] = 416, + [417] = 374, + [418] = 375, + [419] = 419, + [420] = 376, + [421] = 378, + [422] = 380, + [423] = 381, + [424] = 384, + [425] = 382, + [426] = 383, + [427] = 384, + [428] = 385, + [429] = 386, + [430] = 387, + [431] = 388, + [432] = 432, + [433] = 385, + [434] = 357, + [435] = 386, + [436] = 340, + [437] = 342, + [438] = 387, + [439] = 439, + [440] = 367, + [441] = 357, + [442] = 371, + [443] = 376, + [444] = 378, + [445] = 380, + [446] = 384, + [447] = 385, + [448] = 386, + [449] = 388, + [450] = 388, + [451] = 339, + [452] = 452, + [453] = 364, + [454] = 399, + [455] = 432, + [456] = 339, + [457] = 364, + [458] = 399, + [459] = 432, + [460] = 339, + [461] = 364, + [462] = 399, + [463] = 432, + [464] = 357, + [465] = 465, + [466] = 466, + [467] = 467, + [468] = 468, + [469] = 469, + [470] = 470, + [471] = 471, + [472] = 472, + [473] = 473, + [474] = 474, + [475] = 475, + [476] = 470, + [477] = 477, + [478] = 478, + [479] = 479, + [480] = 480, + [481] = 481, + [482] = 482, + [483] = 483, + [484] = 484, + [485] = 485, + [486] = 486, + [487] = 487, + [488] = 488, + [489] = 489, + [490] = 490, + [491] = 491, + [492] = 492, + [493] = 493, + [494] = 494, + [495] = 495, + [496] = 496, + [497] = 497, + [498] = 498, + [499] = 499, + [500] = 500, + [501] = 501, + [502] = 502, + [503] = 500, + [504] = 504, + [505] = 505, + [506] = 479, + [507] = 507, + [508] = 508, + [509] = 509, + [510] = 475, + [511] = 511, + [512] = 475, + [513] = 502, + [514] = 514, + [515] = 515, + [516] = 516, + [517] = 489, + [518] = 518, + [519] = 516, + [520] = 520, + [521] = 516, + [522] = 522, + [523] = 25, + [524] = 494, + [525] = 494, + [526] = 526, + [527] = 527, + [528] = 522, + [529] = 529, + [530] = 530, + [531] = 531, + [532] = 532, + [533] = 522, + [534] = 534, + [535] = 535, + [536] = 536, + [537] = 480, + [538] = 538, + [539] = 532, + [540] = 540, + [541] = 541, + [542] = 532, + [543] = 543, + [544] = 544, + [545] = 470, + [546] = 546, + [547] = 495, + [548] = 548, + [549] = 536, + [550] = 508, + [551] = 515, + [552] = 552, + [553] = 540, + [554] = 520, + [555] = 543, + [556] = 493, + [557] = 526, + [558] = 558, + [559] = 529, + [560] = 560, + [561] = 480, + [562] = 558, + [563] = 495, + [564] = 564, + [565] = 565, + [566] = 566, + [567] = 567, + [568] = 568, + [569] = 569, + [570] = 489, + [571] = 571, + [572] = 572, + [573] = 573, + [574] = 508, + [575] = 500, + [576] = 576, + [577] = 577, + [578] = 578, + [579] = 579, + [580] = 515, + [581] = 564, + [582] = 582, + [583] = 498, + [584] = 565, + [585] = 26, + [586] = 520, + [587] = 500, + [588] = 567, + [589] = 568, + [590] = 569, + [591] = 479, + [592] = 536, + [593] = 593, + [594] = 594, + [595] = 526, + [596] = 494, + [597] = 597, + [598] = 598, + [599] = 599, + [600] = 522, + [601] = 529, + [602] = 571, + [603] = 532, + [604] = 493, + [605] = 27, + [606] = 495, + [607] = 607, + [608] = 558, + [609] = 508, + [610] = 572, + [611] = 515, + [612] = 612, + [613] = 564, + [614] = 558, + [615] = 565, + [616] = 564, + [617] = 565, + [618] = 479, + [619] = 571, + [620] = 572, + [621] = 573, + [622] = 567, + [623] = 576, + [624] = 573, + [625] = 568, + [626] = 626, + [627] = 569, + [628] = 490, + [629] = 552, + [630] = 630, + [631] = 498, + [632] = 571, + [633] = 509, + [634] = 572, + [635] = 501, + [636] = 573, + [637] = 578, + [638] = 607, + [639] = 576, + [640] = 640, + [641] = 490, + [642] = 552, + [643] = 643, + [644] = 626, + [645] = 509, + [646] = 576, + [647] = 501, + [648] = 648, + [649] = 578, + [650] = 607, + [651] = 498, + [652] = 652, + [653] = 490, + [654] = 540, + [655] = 509, + [656] = 656, + [657] = 543, + [658] = 501, + [659] = 502, + [660] = 578, + [661] = 607, + [662] = 626, + [663] = 663, + [664] = 664, + [665] = 665, + [666] = 666, + [667] = 667, + [668] = 668, + [669] = 669, + [670] = 670, + [671] = 671, + [672] = 672, + [673] = 673, + [674] = 674, + [675] = 675, + [676] = 676, + [677] = 677, + [678] = 678, + [679] = 679, + [680] = 680, + [681] = 681, + [682] = 682, + [683] = 683, + [684] = 684, + [685] = 685, + [686] = 686, + [687] = 687, + [688] = 688, + [689] = 689, + [690] = 690, + [691] = 691, + [692] = 692, + [693] = 693, + [694] = 694, + [695] = 695, + [696] = 696, + [697] = 697, + [698] = 698, + [699] = 699, + [700] = 700, + [701] = 701, + [702] = 702, + [703] = 703, + [704] = 704, + [705] = 705, + [706] = 706, + [707] = 707, + [708] = 708, + [709] = 709, + [710] = 710, + [711] = 711, + [712] = 712, + [713] = 712, + [714] = 712, + [715] = 712, + [716] = 712, + [717] = 712, + [718] = 718, + [719] = 718, + [720] = 718, + [721] = 718, + [722] = 718, + [723] = 718, + [724] = 724, + [725] = 725, + [726] = 726, + [727] = 727, + [728] = 728, + [729] = 729, + [730] = 730, + [731] = 731, + [732] = 732, + [733] = 733, + [734] = 734, + [735] = 734, + [736] = 736, + [737] = 734, + [738] = 734, + [739] = 739, + [740] = 740, + [741] = 741, + [742] = 742, + [743] = 743, + [744] = 736, + [745] = 742, + [746] = 746, + [747] = 740, + [748] = 736, + [749] = 740, + [750] = 742, + [751] = 751, + [752] = 751, + [753] = 742, + [754] = 740, + [755] = 755, + [756] = 756, + [757] = 751, + [758] = 751, + [759] = 755, + [760] = 760, + [761] = 743, + [762] = 762, + [763] = 746, + [764] = 741, + [765] = 765, + [766] = 746, + [767] = 741, + [768] = 768, + [769] = 743, + [770] = 762, + [771] = 771, + [772] = 772, + [773] = 773, + [774] = 771, + [775] = 775, + [776] = 776, + [777] = 777, + [778] = 773, + [779] = 777, + [780] = 772, + [781] = 781, + [782] = 782, + [783] = 772, + [784] = 772, + [785] = 771, + [786] = 786, + [787] = 787, + [788] = 788, + [789] = 789, + [790] = 777, + [791] = 777, + [792] = 771, + [793] = 793, + [794] = 781, + [795] = 787, + [796] = 788, + [797] = 797, + [798] = 789, + [799] = 786, + [800] = 800, + [801] = 801, + [802] = 802, + [803] = 803, + [804] = 804, + [805] = 805, + [806] = 806, + [807] = 807, + [808] = 808, + [809] = 809, + [810] = 810, + [811] = 811, + [812] = 797, + [813] = 813, + [814] = 814, + [815] = 815, + [816] = 816, + [817] = 817, + [818] = 818, + [819] = 819, + [820] = 820, + [821] = 821, + [822] = 822, + [823] = 823, + [824] = 824, + [825] = 825, + [826] = 826, + [827] = 827, + [828] = 828, + [829] = 829, + [830] = 830, + [831] = 781, + [832] = 832, + [833] = 787, + [834] = 788, + [835] = 566, + [836] = 836, + [837] = 786, + [838] = 838, + [839] = 839, + [840] = 840, + [841] = 811, + [842] = 789, + [843] = 697, + [844] = 807, + [845] = 813, + [846] = 814, + [847] = 815, + [848] = 816, + [849] = 818, + [850] = 819, + [851] = 820, + [852] = 793, + [853] = 821, + [854] = 822, + [855] = 823, + [856] = 824, + [857] = 825, + [858] = 826, + [859] = 827, + [860] = 828, + [861] = 829, + [862] = 830, + [863] = 808, + [864] = 864, + [865] = 865, + [866] = 866, + [867] = 867, + [868] = 868, + [869] = 869, + [870] = 870, + [871] = 871, + [872] = 872, + [873] = 873, + [874] = 809, + [875] = 875, + [876] = 801, + [877] = 877, + [878] = 878, + [879] = 879, + [880] = 880, + [881] = 881, + [882] = 801, + [883] = 883, + [884] = 802, + [885] = 803, + [886] = 804, + [887] = 887, + [888] = 888, + [889] = 889, + [890] = 890, + [891] = 891, + [892] = 892, + [893] = 806, + [894] = 894, + [895] = 895, + [896] = 896, + [897] = 897, + [898] = 898, + [899] = 899, + [900] = 900, + [901] = 901, + [902] = 902, + [903] = 903, + [904] = 904, + [905] = 905, + [906] = 906, + [907] = 907, + [908] = 908, + [909] = 909, + [910] = 910, + [911] = 911, + [912] = 912, + [913] = 913, + [914] = 802, + [915] = 694, + [916] = 680, + [917] = 691, + [918] = 693, + [919] = 688, + [920] = 674, + [921] = 685, + [922] = 686, + [923] = 692, + [924] = 705, + [925] = 671, + [926] = 704, + [927] = 710, + [928] = 708, + [929] = 676, + [930] = 678, + [931] = 830, + [932] = 698, + [933] = 706, + [934] = 672, + [935] = 673, + [936] = 675, + [937] = 681, + [938] = 683, + [939] = 684, + [940] = 687, + [941] = 711, + [942] = 690, + [943] = 695, + [944] = 696, + [945] = 699, + [946] = 700, + [947] = 703, + [948] = 803, + [949] = 875, + [950] = 804, + [951] = 951, + [952] = 952, + [953] = 953, + [954] = 954, + [955] = 806, + [956] = 956, + [957] = 957, + [958] = 958, + [959] = 959, + [960] = 957, + [961] = 959, + [962] = 962, + [963] = 807, + [964] = 813, + [965] = 814, + [966] = 966, + [967] = 808, + [968] = 815, + [969] = 816, + [970] = 970, + [971] = 809, + [972] = 972, + [973] = 875, + [974] = 974, + [975] = 975, + [976] = 953, + [977] = 954, + [978] = 966, + [979] = 818, + [980] = 819, + [981] = 957, + [982] = 959, + [983] = 820, + [984] = 793, + [985] = 985, + [986] = 966, + [987] = 970, + [988] = 970, + [989] = 953, + [990] = 954, + [991] = 821, + [992] = 822, + [993] = 823, + [994] = 824, + [995] = 957, + [996] = 959, + [997] = 997, + [998] = 966, + [999] = 970, + [1000] = 875, + [1001] = 953, + [1002] = 954, + [1003] = 825, + [1004] = 826, + [1005] = 827, + [1006] = 828, + [1007] = 829, + [1008] = 679, + [1009] = 907, + [1010] = 687, + [1011] = 711, + [1012] = 690, + [1013] = 691, + [1014] = 695, + [1015] = 693, + [1016] = 696, + [1017] = 688, + [1018] = 697, + [1019] = 877, + [1020] = 690, + [1021] = 692, + [1022] = 696, + [1023] = 697, + [1024] = 908, + [1025] = 909, + [1026] = 878, + [1027] = 708, + [1028] = 910, + [1029] = 879, + [1030] = 699, + [1031] = 700, + [1032] = 911, + [1033] = 676, + [1034] = 703, + [1035] = 699, + [1036] = 700, + [1037] = 912, + [1038] = 913, + [1039] = 703, + [1040] = 881, + [1041] = 678, + [1042] = 679, + [1043] = 868, + [1044] = 895, + [1045] = 896, + [1046] = 889, + [1047] = 897, + [1048] = 890, + [1049] = 898, + [1050] = 671, + [1051] = 1051, + [1052] = 869, + [1053] = 870, + [1054] = 871, + [1055] = 872, + [1056] = 1056, + [1057] = 883, + [1058] = 899, + [1059] = 891, + [1060] = 698, + [1061] = 694, + [1062] = 680, + [1063] = 691, + [1064] = 913, + [1065] = 693, + [1066] = 688, + [1067] = 706, + [1068] = 864, + [1069] = 672, + [1070] = 865, + [1071] = 866, + [1072] = 867, + [1073] = 1073, + [1074] = 868, + [1075] = 1075, + [1076] = 869, + [1077] = 673, + [1078] = 663, + [1079] = 873, + [1080] = 675, + [1081] = 878, + [1082] = 1082, + [1083] = 870, + [1084] = 1084, + [1085] = 871, + [1086] = 872, + [1087] = 900, + [1088] = 705, + [1089] = 873, + [1090] = 901, + [1091] = 1091, + [1092] = 892, + [1093] = 1093, + [1094] = 656, + [1095] = 518, + [1096] = 1096, + [1097] = 1097, + [1098] = 902, + [1099] = 887, + [1100] = 880, + [1101] = 1082, + [1102] = 674, + [1103] = 685, + [1104] = 26, + [1105] = 686, + [1106] = 667, + [1107] = 1107, + [1108] = 692, + [1109] = 887, + [1110] = 888, + [1111] = 889, + [1112] = 890, + [1113] = 705, + [1114] = 1114, + [1115] = 881, + [1116] = 891, + [1117] = 671, + [1118] = 1118, + [1119] = 903, + [1120] = 892, + [1121] = 894, + [1122] = 883, + [1123] = 894, + [1124] = 681, + [1125] = 1125, + [1126] = 879, + [1127] = 1127, + [1128] = 1128, + [1129] = 683, + [1130] = 865, + [1131] = 684, + [1132] = 687, + [1133] = 1133, + [1134] = 1134, + [1135] = 1091, + [1136] = 704, + [1137] = 27, + [1138] = 668, + [1139] = 1139, + [1140] = 895, + [1141] = 896, + [1142] = 710, + [1143] = 897, + [1144] = 708, + [1145] = 676, + [1146] = 678, + [1147] = 898, + [1148] = 679, + [1149] = 1051, + [1150] = 899, + [1151] = 866, + [1152] = 711, + [1153] = 904, + [1154] = 1091, + [1155] = 674, + [1156] = 888, + [1157] = 877, + [1158] = 905, + [1159] = 900, + [1160] = 864, + [1161] = 901, + [1162] = 867, + [1163] = 902, + [1164] = 698, + [1165] = 1118, + [1166] = 903, + [1167] = 706, + [1168] = 672, + [1169] = 673, + [1170] = 675, + [1171] = 906, + [1172] = 704, + [1173] = 880, + [1174] = 25, + [1175] = 1091, + [1176] = 685, + [1177] = 1177, + [1178] = 907, + [1179] = 904, + [1180] = 694, + [1181] = 905, + [1182] = 710, + [1183] = 906, + [1184] = 680, + [1185] = 1185, + [1186] = 681, + [1187] = 908, + [1188] = 909, + [1189] = 683, + [1190] = 910, + [1191] = 911, + [1192] = 684, + [1193] = 686, + [1194] = 912, + [1195] = 695, + [1196] = 1196, + [1197] = 1197, + [1198] = 1198, + [1199] = 1197, + [1200] = 1200, + [1201] = 1197, + [1202] = 1202, + [1203] = 1203, + [1204] = 1197, + [1205] = 1205, + [1206] = 1206, + [1207] = 1207, + [1208] = 1208, + [1209] = 1209, + [1210] = 1210, + [1211] = 1211, + [1212] = 1212, + [1213] = 1209, + [1214] = 1209, + [1215] = 1215, + [1216] = 1216, + [1217] = 1217, + [1218] = 1209, + [1219] = 1219, + [1220] = 1220, + [1221] = 1221, + [1222] = 1222, + [1223] = 1223, + [1224] = 1224, + [1225] = 1225, + [1226] = 1226, + [1227] = 1227, + [1228] = 1228, + [1229] = 1229, + [1230] = 1230, + [1231] = 1231, + [1232] = 1232, + [1233] = 1233, + [1234] = 1234, + [1235] = 1235, + [1236] = 24, + [1237] = 1237, + [1238] = 1238, + [1239] = 1239, + [1240] = 1240, + [1241] = 1241, + [1242] = 1242, + [1243] = 1243, + [1244] = 1244, + [1245] = 1245, + [1246] = 1246, + [1247] = 1247, + [1248] = 1248, + [1249] = 1249, + [1250] = 1250, + [1251] = 1251, + [1252] = 1252, + [1253] = 1253, + [1254] = 1248, + [1255] = 1255, + [1256] = 1256, + [1257] = 1257, + [1258] = 1258, + [1259] = 1259, + [1260] = 1260, + [1261] = 1261, + [1262] = 1262, + [1263] = 1263, + [1264] = 1264, + [1265] = 1265, + [1266] = 1266, + [1267] = 1267, + [1268] = 1268, + [1269] = 1269, + [1270] = 1270, + [1271] = 1271, + [1272] = 1272, + [1273] = 1273, + [1274] = 1274, + [1275] = 1275, + [1276] = 1276, + [1277] = 1277, + [1278] = 1278, + [1279] = 1279, + [1280] = 1280, + [1281] = 1281, + [1282] = 1253, + [1283] = 1283, + [1284] = 1248, + [1285] = 1285, + [1286] = 1248, + [1287] = 1287, + [1288] = 1288, + [1289] = 1289, + [1290] = 1290, + [1291] = 1291, + [1292] = 1292, + [1293] = 1293, + [1294] = 1292, + [1295] = 1295, + [1296] = 1296, + [1297] = 1297, + [1298] = 1298, + [1299] = 1299, + [1300] = 1300, + [1301] = 1301, + [1302] = 1302, + [1303] = 1303, + [1304] = 1304, + [1305] = 1305, + [1306] = 1306, + [1307] = 1307, + [1308] = 1308, + [1309] = 1309, + [1310] = 1310, + [1311] = 1311, + [1312] = 1312, + [1313] = 1313, + [1314] = 1312, + [1315] = 1315, + [1316] = 1316, + [1317] = 1290, + [1318] = 1318, + [1319] = 1296, + [1320] = 1320, + [1321] = 1321, + [1322] = 1322, + [1323] = 1323, + [1324] = 1324, + [1325] = 1302, + [1326] = 1297, + [1327] = 1327, + [1328] = 1328, + [1329] = 1329, + [1330] = 1330, + [1331] = 1331, + [1332] = 1315, + [1333] = 1333, + [1334] = 1334, + [1335] = 1309, + [1336] = 1336, + [1337] = 1337, + [1338] = 1338, + [1339] = 1339, + [1340] = 1291, + [1341] = 1341, + [1342] = 1307, + [1343] = 1343, + [1344] = 1320, + [1345] = 1345, + [1346] = 1292, + [1347] = 1292, + [1348] = 1336, + [1349] = 1349, + [1350] = 1290, + [1351] = 1351, + [1352] = 1352, + [1353] = 1353, + [1354] = 1312, + [1355] = 1312, + [1356] = 1291, + [1357] = 1357, + [1358] = 1358, + [1359] = 1359, + [1360] = 1360, + [1361] = 1361, + [1362] = 1362, + [1363] = 1363, + [1364] = 1297, + [1365] = 1365, + [1366] = 1366, + [1367] = 1367, + [1368] = 1368, + [1369] = 1369, + [1370] = 1370, + [1371] = 1336, + [1372] = 1372, + [1373] = 1307, + [1374] = 1309, + [1375] = 1302, + [1376] = 1320, + [1377] = 1377, + [1378] = 1321, + [1379] = 1307, + [1380] = 1380, + [1381] = 1381, + [1382] = 1296, + [1383] = 1383, + [1384] = 1384, + [1385] = 1337, + [1386] = 1386, + [1387] = 1387, + [1388] = 1388, + [1389] = 1389, + [1390] = 1321, + [1391] = 1391, + [1392] = 1392, + [1393] = 1393, + [1394] = 1394, + [1395] = 1395, + [1396] = 1396, + [1397] = 1336, + [1398] = 1398, + [1399] = 1399, + [1400] = 1320, + [1401] = 1401, + [1402] = 1402, + [1403] = 1297, + [1404] = 1404, + [1405] = 1381, + [1406] = 1406, + [1407] = 1315, + [1408] = 1408, + [1409] = 1370, + [1410] = 1313, + [1411] = 1313, + [1412] = 1313, + [1413] = 1413, + [1414] = 1414, + [1415] = 1415, + [1416] = 1416, + [1417] = 1417, + [1418] = 1418, + [1419] = 1419, + [1420] = 1420, + [1421] = 1421, + [1422] = 1422, + [1423] = 1423, + [1424] = 1424, + [1425] = 1425, + [1426] = 1426, + [1427] = 1427, + [1428] = 1428, + [1429] = 1429, + [1430] = 1430, + [1431] = 1431, + [1432] = 1427, + [1433] = 1433, + [1434] = 1427, + [1435] = 1435, + [1436] = 1436, + [1437] = 1437, + [1438] = 1438, + [1439] = 1439, + [1440] = 1440, + [1441] = 1441, + [1442] = 1423, + [1443] = 1443, + [1444] = 1443, + [1445] = 1423, + [1446] = 1446, + [1447] = 1423, + [1448] = 1448, + [1449] = 1449, + [1450] = 1450, + [1451] = 1451, + [1452] = 1452, + [1453] = 1453, + [1454] = 1454, + [1455] = 1455, + [1456] = 1456, + [1457] = 1457, + [1458] = 1458, + [1459] = 1453, + [1460] = 1460, + [1461] = 1461, + [1462] = 1462, + [1463] = 1463, + [1464] = 1464, + [1465] = 1465, + [1466] = 1466, + [1467] = 1467, + [1468] = 1468, + [1469] = 1469, + [1470] = 1470, + [1471] = 1471, + [1472] = 1472, + [1473] = 1469, + [1474] = 1474, + [1475] = 1475, + [1476] = 1476, + [1477] = 1477, + [1478] = 1478, + [1479] = 1479, + [1480] = 1480, + [1481] = 1481, + [1482] = 1482, + [1483] = 1462, + [1484] = 1484, + [1485] = 1472, + [1486] = 1486, + [1487] = 1487, + [1488] = 1488, + [1489] = 1488, + [1490] = 1458, + [1491] = 1491, + [1492] = 1492, + [1493] = 1493, + [1494] = 1494, + [1495] = 1495, + [1496] = 1496, + [1497] = 1495, + [1498] = 1498, + [1499] = 1495, + [1500] = 1500, + [1501] = 1460, + [1502] = 1502, + [1503] = 1503, + [1504] = 1488, + [1505] = 1505, + [1506] = 1506, + [1507] = 1491, + [1508] = 1508, + [1509] = 1509, + [1510] = 1510, + [1511] = 1511, + [1512] = 1465, + [1513] = 1474, + [1514] = 1514, + [1515] = 1463, + [1516] = 1462, + [1517] = 1517, + [1518] = 1509, + [1519] = 1510, + [1520] = 1520, + [1521] = 1521, + [1522] = 1522, + [1523] = 1523, + [1524] = 1510, + [1525] = 1525, + [1526] = 1526, + [1527] = 1527, + [1528] = 1469, + [1529] = 1529, + [1530] = 1530, + [1531] = 1531, + [1532] = 1532, + [1533] = 1533, + [1534] = 1534, + [1535] = 1535, + [1536] = 1536, + [1537] = 1453, + [1538] = 1538, + [1539] = 1539, + [1540] = 1540, + [1541] = 1541, + [1542] = 1460, + [1543] = 1486, + [1544] = 1544, + [1545] = 1463, + [1546] = 1491, + [1547] = 1547, + [1548] = 1491, + [1549] = 1510, + [1550] = 1550, + [1551] = 1551, + [1552] = 1544, + [1553] = 1535, + [1554] = 1554, + [1555] = 1510, + [1556] = 1556, + [1557] = 1521, + [1558] = 1558, + [1559] = 1559, + [1560] = 1453, + [1561] = 1561, + [1562] = 1562, + [1563] = 1563, + [1564] = 1564, + [1565] = 1565, + [1566] = 1566, + [1567] = 1465, + [1568] = 1538, + [1569] = 1464, + [1570] = 1570, + [1571] = 1571, + [1572] = 1572, + [1573] = 1573, + [1574] = 1514, + [1575] = 1575, + [1576] = 1498, + [1577] = 1525, + [1578] = 1578, + [1579] = 1579, + [1580] = 1580, + [1581] = 1581, + [1582] = 1556, + [1583] = 1583, + [1584] = 1458, + [1585] = 1452, + [1586] = 1586, + [1587] = 1587, + [1588] = 1588, + [1589] = 1521, + [1590] = 1538, + [1591] = 1495, + [1592] = 1592, + [1593] = 1593, + [1594] = 1594, + [1595] = 1595, + [1596] = 1474, + [1597] = 1597, + [1598] = 1598, + [1599] = 1599, + [1600] = 1600, + [1601] = 1601, + [1602] = 1602, + [1603] = 1603, + [1604] = 1514, + [1605] = 1491, + [1606] = 1606, + [1607] = 1460, + [1608] = 1608, + [1609] = 1609, + [1610] = 1610, + [1611] = 1611, + [1612] = 1525, + [1613] = 1514, + [1614] = 1614, + [1615] = 1615, + [1616] = 1616, + [1617] = 1525, + [1618] = 1469, + [1619] = 1619, + [1620] = 1620, + [1621] = 1621, + [1622] = 1491, + [1623] = 1623, + [1624] = 1511, + [1625] = 1463, + [1626] = 1563, + [1627] = 1627, + [1628] = 1472, + [1629] = 1581, + [1630] = 1630, + [1631] = 1631, + [1632] = 1632, + [1633] = 1498, + [1634] = 1509, + [1635] = 1510, + [1636] = 1636, + [1637] = 1637, + [1638] = 1638, + [1639] = 1639, + [1640] = 1640, +}; + +static const TSCharacterRange sym_identifier_character_set_2[] = { + {'!', '!'}, {'#', '\''}, {'*', ':'}, {'<', 'Z'}, {'\\', '\\'}, {'^', 'z'}, {'|', '|'}, {'~', '~'}, + {0x17f, 0x17f}, {0x212a, 0x212a}, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(397); + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + ')', 404, + '0', 772, + ';', 39, + 'a', 217, + 'b', 226, + 'c', 80, + 'd', 82, + 'e', 218, + 'f', 57, + 'g', 229, + 'i', 43, + 'l', 278, + 'm', 137, + 'n', 93, + 'o', 198, + 'p', 83, + 'r', 138, + 's', 206, + 't', 84, + 'u', 248, + 'v', 47, + '+', 40, + '-', 40, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 1: + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + ')', 404, + '0', 772, + ';', 74, + 'a', 217, + 'c', 280, + 'e', 293, + 'f', 60, + 'i', 49, + 'n', 94, + 'o', 201, + 's', 347, + '+', 40, + '-', 40, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(1); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 2: + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + ')', 404, + '0', 772, + ';', 74, + 'a', 660, + 'b', 666, + 'c', 565, + 'e', 714, + 'f', 548, + 'i', 542, + 'l', 704, + 'n', 568, + 'o', 647, + 'r', 599, + 's', 750, + 't', 717, + '+', 40, + '-', 40, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(2); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('d' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 3: + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + ')', 404, + '0', 808, + ';', 74, + 'a', 262, + 'c', 289, + 'd', 135, + 'e', 294, + 'f', 58, + 'i', 50, + 'n', 360, + 's', 207, + 'u', 248, + 'v', 47, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(3); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(809); + END_STATE(); + case 4: + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + '0', 772, + ';', 74, + 'a', 660, + 'b', 666, + 'c', 565, + 'e', 661, + 'f', 548, + 'i', 542, + 'l', 704, + 'n', 568, + 'o', 647, + 'r', 599, + 's', 750, + 't', 717, + '+', 40, + '-', 40, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(4); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('d' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 5: + ADVANCE_MAP( + '"', 6, + '$', 7, + '(', 400, + '0', 772, + ';', 74, + 'a', 660, + 'b', 666, + 'c', 565, + 'e', 680, + 'f', 548, + 'i', 542, + 'l', 704, + 'n', 568, + 'o', 647, + 'r', 599, + 's', 750, + 't', 717, + '+', 40, + '-', 40, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(5); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('d' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 6: + if (lookahead == '"') ADVANCE(806); + if (lookahead == '\\') ADVANCE(8); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(6); + END_STATE(); + case 7: + if (lookahead == '"') ADVANCE(9); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(541); + END_STATE(); + case 8: + if (lookahead == '"') ADVANCE(807); + if (lookahead == '\\') ADVANCE(8); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(6); + END_STATE(); + case 9: + if (lookahead == '"') ADVANCE(540); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(9); + END_STATE(); + case 10: + if (lookahead == '"') ADVANCE(813); + if (lookahead == '\\') ADVANCE(11); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(10); + END_STATE(); + case 11: + if (lookahead == '"') ADVANCE(814); + if (lookahead == '\\') ADVANCE(11); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(10); + END_STATE(); + case 12: + if (lookahead == '"') ADVANCE(10); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(816); + END_STATE(); + case 13: + ADVANCE_MAP( + '$', 7, + '(', 400, + ')', 404, + '0', 808, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(13); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(809); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 14: + ADVANCE_MAP( + '$', 7, + '(', 400, + ';', 74, + 'b', 666, + 'c', 566, + 'e', 662, + 'i', 628, + 'l', 704, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(14); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 15: + ADVANCE_MAP( + '$', 7, + '(', 400, + ';', 74, + 'b', 666, + 'c', 566, + 'e', 681, + 'i', 628, + 'l', 704, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(15); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 16: + ADVANCE_MAP( + '$', 7, + '(', 73, + '0', 808, + ';', 74, + 'a', 265, + 'c', 288, + 'd', 81, + 'e', 239, + 'f', 361, + 'g', 229, + 'i', 59, + 'm', 136, + 'n', 279, + 'r', 164, + 's', 353, + 't', 85, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(16); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(809); + END_STATE(); + case 17: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 563, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(17); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 18: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 563, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 716, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(18); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 19: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 563, + 'i', 628, + 'l', 704, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(19); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 20: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 563, + 'i', 628, + 'l', 704, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(20); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 21: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'e', 765, + 'i', 626, + 'l', 703, + 'p', 569, + 'r', 595, + 't', 716, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(21); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 22: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 627, + 'l', 704, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(22); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 23: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'm', 600, + 'o', 649, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(23); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 24: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'o', 689, + 'r', 597, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(24); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 25: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'o', 649, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(25); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 26: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'o', 649, + 'r', 597, + 't', 572, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(26); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 27: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(27); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 28: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 716, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(28); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 29: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 652, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(29); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 30: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'p', 569, + 'r', 595, + 't', 653, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(30); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 31: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'r', 599, + 't', 653, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(31); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 32: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(32); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 33: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 704, + 'r', 595, + 't', 653, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(33); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 34: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 703, + 'p', 569, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(34); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 35: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 703, + 'p', 569, + 'r', 595, + 't', 716, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(35); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 36: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 703, + 'r', 599, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(36); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 37: + ADVANCE_MAP( + '(', 73, + ';', 74, + 'b', 666, + 'c', 566, + 'i', 628, + 'l', 703, + 'r', 595, + 't', 717, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(37); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 38: + if (lookahead == '(') ADVANCE(822); + if (lookahead == ')') ADVANCE(404); + if (lookahead == ';') ADVANCE(823); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(38); + if (lookahead != 0) ADVANCE(825); + END_STATE(); + case 39: + if (lookahead == ')') ADVANCE(828); + if (lookahead == ';') ADVANCE(829); + END_STATE(); + case 40: + if (lookahead == '0') ADVANCE(772); + if (lookahead == 'i') ADVANCE(247); + if (lookahead == 'n') ADVANCE(92); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 41: + if (lookahead == '0') ADVANCE(787); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(788); + END_STATE(); + case 42: + if (lookahead == '0') ADVANCE(367); + END_STATE(); + case 43: + ADVANCE_MAP( + '1', 67, + '3', 44, + '6', 62, + '8', 495, + 'f', 409, + 'm', 292, + 'n', 181, + 't', 150, + ); + END_STATE(); + case 44: + if (lookahead == '1') ADVANCE(459); + if (lookahead == '2') ADVANCE(398); + END_STATE(); + case 45: + if (lookahead == '1') ADVANCE(459); + if (lookahead == '2') ADVANCE(372); + END_STATE(); + case 46: + if (lookahead == '1') ADVANCE(457); + END_STATE(); + case 47: + if (lookahead == '1') ADVANCE(53); + END_STATE(); + case 48: + if (lookahead == '1') ADVANCE(68); + END_STATE(); + case 49: + if (lookahead == '1') ADVANCE(70); + if (lookahead == '3') ADVANCE(45); + if (lookahead == '6') ADVANCE(66); + if (lookahead == '8') ADVANCE(365); + if (lookahead == 'n') ADVANCE(181); + END_STATE(); + case 50: + if (lookahead == '1') ADVANCE(69); + if (lookahead == '3') ADVANCE(51); + if (lookahead == '6') ADVANCE(62); + if (lookahead == '8') ADVANCE(494); + END_STATE(); + case 51: + if (lookahead == '1') ADVANCE(309); + if (lookahead == '2') ADVANCE(398); + END_STATE(); + case 52: + if (lookahead == '2') ADVANCE(487); + END_STATE(); + case 53: + if (lookahead == '2') ADVANCE(71); + END_STATE(); + case 54: + if (lookahead == '2') ADVANCE(802); + END_STATE(); + case 55: + if (lookahead == '2') ADVANCE(798); + END_STATE(); + case 56: + if (lookahead == '2') ADVANCE(370); + END_STATE(); + case 57: + if (lookahead == '3') ADVANCE(52); + if (lookahead == '6') ADVANCE(61); + if (lookahead == 'i') ADVANCE(155); + if (lookahead == 'u') ADVANCE(261); + END_STATE(); + case 58: + if (lookahead == '3') ADVANCE(52); + if (lookahead == '6') ADVANCE(61); + if (lookahead == 'i') ADVANCE(264); + if (lookahead == 'u') ADVANCE(261); + END_STATE(); + case 59: + if (lookahead == '3') ADVANCE(46); + if (lookahead == 'm') ADVANCE(292); + END_STATE(); + case 60: + if (lookahead == '3') ADVANCE(56); + if (lookahead == '6') ADVANCE(65); + if (lookahead == 'u') ADVANCE(261); + END_STATE(); + case 61: + if (lookahead == '4') ADVANCE(488); + END_STATE(); + case 62: + if (lookahead == '4') ADVANCE(399); + END_STATE(); + case 63: + if (lookahead == '4') ADVANCE(800); + END_STATE(); + case 64: + if (lookahead == '4') ADVANCE(796); + END_STATE(); + case 65: + if (lookahead == '4') ADVANCE(369); + END_STATE(); + case 66: + if (lookahead == '4') ADVANCE(371); + END_STATE(); + case 67: + if (lookahead == '6') ADVANCE(497); + END_STATE(); + case 68: + if (lookahead == '6') ADVANCE(792); + END_STATE(); + case 69: + if (lookahead == '6') ADVANCE(496); + END_STATE(); + case 70: + if (lookahead == '6') ADVANCE(366); + END_STATE(); + case 71: + if (lookahead == '8') ADVANCE(539); + END_STATE(); + case 72: + if (lookahead == '8') ADVANCE(794); + END_STATE(); + case 73: + if (lookahead == ';') ADVANCE(826); + if (lookahead == '@') ADVANCE(12); + END_STATE(); + case 74: + if (lookahead == ';') ADVANCE(829); + END_STATE(); + case 75: + if (lookahead == '=') ADVANCE(41); + END_STATE(); + case 76: + if (lookahead == '_') ADVANCE(212); + END_STATE(); + case 77: + if (lookahead == '_') ADVANCE(119); + END_STATE(); + case 78: + if (lookahead == '_') ADVANCE(349); + END_STATE(); + case 79: + if (lookahead == '_') ADVANCE(215); + END_STATE(); + case 80: + if (lookahead == 'a') ADVANCE(228); + if (lookahead == 'o') ADVANCE(259); + END_STATE(); + case 81: + if (lookahead == 'a') ADVANCE(346); + END_STATE(); + case 82: + if (lookahead == 'a') ADVANCE(346); + if (lookahead == 'e') ADVANCE(117); + END_STATE(); + case 83: + if (lookahead == 'a') ADVANCE(203); + END_STATE(); + case 84: + if (lookahead == 'a') ADVANCE(106); + if (lookahead == 'h') ADVANCE(157); + if (lookahead == 'r') ADVANCE(374); + if (lookahead == 'y') ADVANCE(291); + END_STATE(); + case 85: + if (lookahead == 'a') ADVANCE(106); + if (lookahead == 'y') ADVANCE(291); + END_STATE(); + case 86: + if (lookahead == 'a') ADVANCE(434); + END_STATE(); + case 87: + if (lookahead == 'a') ADVANCE(311); + END_STATE(); + case 88: + if (lookahead == 'a') ADVANCE(375); + END_STATE(); + case 89: + if (lookahead == 'a') ADVANCE(299); + if (lookahead == 'r') ADVANCE(354); + END_STATE(); + case 90: + if (lookahead == 'a') ADVANCE(299); + if (lookahead == 'r') ADVANCE(363); + END_STATE(); + case 91: + if (lookahead == 'a') ADVANCE(108); + END_STATE(); + case 92: + if (lookahead == 'a') ADVANCE(251); + END_STATE(); + case 93: + if (lookahead == 'a') ADVANCE(251); + if (lookahead == 'o') ADVANCE(118); + if (lookahead == 'u') ADVANCE(231); + END_STATE(); + case 94: + if (lookahead == 'a') ADVANCE(251); + if (lookahead == 'o') ADVANCE(118); + if (lookahead == 'u') ADVANCE(234); + END_STATE(); + case 95: + if (lookahead == 'a') ADVANCE(245); + END_STATE(); + case 96: + if (lookahead == 'a') ADVANCE(378); + END_STATE(); + case 97: + if (lookahead == 'a') ADVANCE(220); + END_STATE(); + case 98: + if (lookahead == 'a') ADVANCE(221); + END_STATE(); + case 99: + if (lookahead == 'a') ADVANCE(222); + END_STATE(); + case 100: + if (lookahead == 'a') ADVANCE(233); + if (lookahead == 'r') ADVANCE(166); + END_STATE(); + case 101: + if (lookahead == 'a') ADVANCE(315); + END_STATE(); + case 102: + if (lookahead == 'a') ADVANCE(242); + END_STATE(); + case 103: + if (lookahead == 'a') ADVANCE(316); + END_STATE(); + case 104: + if (lookahead == 'a') ADVANCE(380); + END_STATE(); + case 105: + if (lookahead == 'b') ADVANCE(535); + END_STATE(); + case 106: + if (lookahead == 'b') ADVANCE(236); + if (lookahead == 'g') ADVANCE(448); + END_STATE(); + case 107: + if (lookahead == 'b') ADVANCE(99); + END_STATE(); + case 108: + if (lookahead == 'b') ADVANCE(238); + END_STATE(); + case 109: + if (lookahead == 'c') ADVANCE(500); + END_STATE(); + case 110: + if (lookahead == 'c') ADVANCE(500); + if (lookahead == 'f') ADVANCE(529); + if (lookahead == 's') ADVANCE(355); + if (lookahead == 't') ADVANCE(357); + END_STATE(); + case 111: + if (lookahead == 'c') ADVANCE(216); + END_STATE(); + case 112: + if (lookahead == 'c') ADVANCE(439); + END_STATE(); + case 113: + if (lookahead == 'c') ADVANCE(465); + END_STATE(); + case 114: + if (lookahead == 'c') ADVANCE(438); + END_STATE(); + case 115: + if (lookahead == 'c') ADVANCE(204); + END_STATE(); + case 116: + if (lookahead == 'c') ADVANCE(205); + END_STATE(); + case 117: + if (lookahead == 'c') ADVANCE(240); + END_STATE(); + case 118: + if (lookahead == 'c') ADVANCE(284); + if (lookahead == 'e') ADVANCE(364); + if (lookahead == 'f') ADVANCE(356); + if (lookahead == 'n') ADVANCE(140); + END_STATE(); + case 119: + if (lookahead == 'c') ADVANCE(102); + END_STATE(); + case 120: + if (lookahead == 'c') ADVANCE(341); + END_STATE(); + case 121: + if (lookahead == 'c') ADVANCE(342); + END_STATE(); + case 122: + if (lookahead == 'c') ADVANCE(343); + END_STATE(); + case 123: + if (lookahead == 'c') ADVANCE(345); + END_STATE(); + case 124: + if (lookahead == 'c') ADVANCE(98); + if (lookahead == 'o') ADVANCE(290); + END_STATE(); + case 125: + if (lookahead == 'c') ADVANCE(323); + END_STATE(); + case 126: + if (lookahead == 'c') ADVANCE(286); + if (lookahead == 'e') ADVANCE(368); + if (lookahead == 'f') ADVANCE(359); + if (lookahead == 'r') ADVANCE(163); + END_STATE(); + case 127: + if (lookahead == 'c') ADVANCE(352); + END_STATE(); + case 128: + if (lookahead == 'd') ADVANCE(407); + END_STATE(); + case 129: + if (lookahead == 'd') ADVANCE(358); + END_STATE(); + case 130: + if (lookahead == 'd') ADVANCE(449); + END_STATE(); + case 131: + if (lookahead == 'd') ADVANCE(804); + END_STATE(); + case 132: + if (lookahead == 'd') ADVANCE(805); + END_STATE(); + case 133: + if (lookahead == 'd') ADVANCE(213); + END_STATE(); + case 134: + if (lookahead == 'd') ADVANCE(214); + END_STATE(); + case 135: + if (lookahead == 'e') ADVANCE(117); + END_STATE(); + case 136: + if (lookahead == 'e') ADVANCE(246); + if (lookahead == 'o') ADVANCE(129); + END_STATE(); + case 137: + if (lookahead == 'e') ADVANCE(246); + if (lookahead == 'o') ADVANCE(129); + if (lookahead == 'u') ADVANCE(332); + END_STATE(); + case 138: + if (lookahead == 'e') ADVANCE(110); + END_STATE(); + case 139: + if (lookahead == 'e') ADVANCE(411); + END_STATE(); + case 140: + if (lookahead == 'e') ADVANCE(463); + END_STATE(); + case 141: + if (lookahead == 'e') ADVANCE(537); + END_STATE(); + case 142: + if (lookahead == 'e') ADVANCE(444); + END_STATE(); + case 143: + if (lookahead == 'e') ADVANCE(484); + END_STATE(); + case 144: + if (lookahead == 'e') ADVANCE(485); + END_STATE(); + case 145: + if (lookahead == 'e') ADVANCE(483); + END_STATE(); + case 146: + if (lookahead == 'e') ADVANCE(417); + END_STATE(); + case 147: + if (lookahead == 'e') ADVANCE(243); + END_STATE(); + case 148: + if (lookahead == 'e') ADVANCE(243); + if (lookahead == 's') ADVANCE(139); + END_STATE(); + case 149: + if (lookahead == 'e') ADVANCE(182); + END_STATE(); + case 150: + if (lookahead == 'e') ADVANCE(244); + END_STATE(); + case 151: + if (lookahead == 'e') ADVANCE(329); + END_STATE(); + case 152: + if (lookahead == 'e') ADVANCE(302); + END_STATE(); + case 153: + if (lookahead == 'e') ADVANCE(131); + END_STATE(); + case 154: + if (lookahead == 'e') ADVANCE(183); + END_STATE(); + case 155: + if (lookahead == 'e') ADVANCE(230); + if (lookahead == 'n') ADVANCE(97); + END_STATE(); + case 156: + if (lookahead == 'e') ADVANCE(184); + END_STATE(); + case 157: + if (lookahead == 'e') ADVANCE(252); + END_STATE(); + case 158: + if (lookahead == 'e') ADVANCE(132); + END_STATE(); + case 159: + if (lookahead == 'e') ADVANCE(185); + END_STATE(); + case 160: + if (lookahead == 'e') ADVANCE(186); + END_STATE(); + case 161: + if (lookahead == 'e') ADVANCE(187); + END_STATE(); + case 162: + if (lookahead == 'e') ADVANCE(339); + END_STATE(); + case 163: + if (lookahead == 'e') ADVANCE(188); + END_STATE(); + case 164: + if (lookahead == 'e') ADVANCE(109); + END_STATE(); + case 165: + if (lookahead == 'e') ADVANCE(189); + END_STATE(); + case 166: + if (lookahead == 'e') ADVANCE(190); + END_STATE(); + case 167: + if (lookahead == 'e') ADVANCE(191); + END_STATE(); + case 168: + if (lookahead == 'e') ADVANCE(192); + END_STATE(); + case 169: + if (lookahead == 'e') ADVANCE(193); + END_STATE(); + case 170: + if (lookahead == 'e') ADVANCE(334); + END_STATE(); + case 171: + if (lookahead == 'e') ADVANCE(194); + END_STATE(); + case 172: + if (lookahead == 'e') ADVANCE(195); + END_STATE(); + case 173: + if (lookahead == 'e') ADVANCE(196); + END_STATE(); + case 174: + if (lookahead == 'e') ADVANCE(197); + END_STATE(); + case 175: + if (lookahead == 'e') ADVANCE(121); + END_STATE(); + case 176: + if (lookahead == 'e') ADVANCE(307); + END_STATE(); + case 177: + if (lookahead == 'e') ADVANCE(122); + END_STATE(); + case 178: + if (lookahead == 'e') ADVANCE(310); + END_STATE(); + case 179: + if (lookahead == 'e') ADVANCE(312); + END_STATE(); + case 180: + if (lookahead == 'e') ADVANCE(326); + END_STATE(); + case 181: + if (lookahead == 'f') ADVANCE(775); + END_STATE(); + case 182: + if (lookahead == 'f') ADVANCE(503); + END_STATE(); + case 183: + if (lookahead == 'f') ADVANCE(501); + END_STATE(); + case 184: + if (lookahead == 'f') ADVANCE(517); + END_STATE(); + case 185: + if (lookahead == 'f') ADVANCE(505); + END_STATE(); + case 186: + if (lookahead == 'f') ADVANCE(525); + END_STATE(); + case 187: + if (lookahead == 'f') ADVANCE(513); + END_STATE(); + case 188: + if (lookahead == 'f') ADVANCE(511); + END_STATE(); + case 189: + if (lookahead == 'f') ADVANCE(509); + END_STATE(); + case 190: + if (lookahead == 'f') ADVANCE(425); + END_STATE(); + case 191: + if (lookahead == 'f') ADVANCE(521); + END_STATE(); + case 192: + if (lookahead == 'f') ADVANCE(507); + END_STATE(); + case 193: + if (lookahead == 'f') ADVANCE(429); + END_STATE(); + case 194: + if (lookahead == 'f') ADVANCE(519); + END_STATE(); + case 195: + if (lookahead == 'f') ADVANCE(527); + END_STATE(); + case 196: + if (lookahead == 'f') ADVANCE(515); + END_STATE(); + case 197: + if (lookahead == 'f') ADVANCE(523); + END_STATE(); + case 198: + if (lookahead == 'f') ADVANCE(199); + if (lookahead == 'n') ADVANCE(491); + END_STATE(); + case 199: + if (lookahead == 'f') ADVANCE(330); + END_STATE(); + case 200: + if (lookahead == 'f') ADVANCE(331); + END_STATE(); + case 201: + if (lookahead == 'f') ADVANCE(200); + END_STATE(); + case 202: + if (lookahead == 'g') ADVANCE(253); + END_STATE(); + case 203: + if (lookahead == 'g') ADVANCE(151); + if (lookahead == 'r') ADVANCE(95); + END_STATE(); + case 204: + if (lookahead == 'h') ADVANCE(424); + END_STATE(); + case 205: + if (lookahead == 'h') ADVANCE(493); + END_STATE(); + case 206: + if (lookahead == 'h') ADVANCE(87); + if (lookahead == 't') ADVANCE(89); + if (lookahead == 'u') ADVANCE(105); + if (lookahead == 'w') ADVANCE(211); + END_STATE(); + case 207: + if (lookahead == 'h') ADVANCE(87); + if (lookahead == 't') ADVANCE(325); + if (lookahead == 'w') ADVANCE(211); + END_STATE(); + case 208: + if (lookahead == 'h') ADVANCE(103); + END_STATE(); + case 209: + if (lookahead == 'i') ADVANCE(202); + END_STATE(); + case 210: + if (lookahead == 'i') ADVANCE(381); + END_STATE(); + case 211: + if (lookahead == 'i') ADVANCE(348); + END_STATE(); + case 212: + if (lookahead == 'i') ADVANCE(263); + END_STATE(); + case 213: + if (lookahead == 'i') ADVANCE(319); + END_STATE(); + case 214: + if (lookahead == 'i') ADVANCE(327); + END_STATE(); + case 215: + if (lookahead == 'i') ADVANCE(277); + END_STATE(); + case 216: + if (lookahead == 'k') ADVANCE(405); + END_STATE(); + case 217: + if (lookahead == 'l') ADVANCE(209); + if (lookahead == 'n') ADVANCE(373); + if (lookahead == 'r') ADVANCE(295); + END_STATE(); + case 218: + if (lookahead == 'l') ADVANCE(148); + if (lookahead == 'n') ADVANCE(128); + if (lookahead == 'q') ADVANCE(456); + if (lookahead == 'x') ADVANCE(249); + END_STATE(); + case 219: + if (lookahead == 'l') ADVANCE(532); + END_STATE(); + case 220: + if (lookahead == 'l') ADVANCE(536); + END_STATE(); + case 221: + if (lookahead == 'l') ADVANCE(481); + END_STATE(); + case 222: + if (lookahead == 'l') ADVANCE(443); + END_STATE(); + case 223: + if (lookahead == 'l') ADVANCE(427); + END_STATE(); + case 224: + if (lookahead == 'l') ADVANCE(126); + END_STATE(); + case 225: + if (lookahead == 'l') ADVANCE(531); + END_STATE(); + case 226: + if (lookahead == 'l') ADVANCE(281); + END_STATE(); + case 227: + if (lookahead == 'l') ADVANCE(76); + END_STATE(); + case 228: + if (lookahead == 'l') ADVANCE(227); + if (lookahead == 't') ADVANCE(115); + END_STATE(); + case 229: + if (lookahead == 'l') ADVANCE(282); + END_STATE(); + case 230: + if (lookahead == 'l') ADVANCE(130); + END_STATE(); + case 231: + if (lookahead == 'l') ADVANCE(219); + END_STATE(); + case 232: + if (lookahead == 'l') ADVANCE(340); + END_STATE(); + case 233: + if (lookahead == 'l') ADVANCE(223); + END_STATE(); + case 234: + if (lookahead == 'l') ADVANCE(224); + END_STATE(); + case 235: + if (lookahead == 'l') ADVANCE(225); + END_STATE(); + case 236: + if (lookahead == 'l') ADVANCE(142); + END_STATE(); + case 237: + if (lookahead == 'l') ADVANCE(143); + END_STATE(); + case 238: + if (lookahead == 'l') ADVANCE(146); + END_STATE(); + case 239: + if (lookahead == 'l') ADVANCE(147); + if (lookahead == 'q') ADVANCE(454); + if (lookahead == 'x') ADVANCE(257); + END_STATE(); + case 240: + if (lookahead == 'l') ADVANCE(101); + END_STATE(); + case 241: + if (lookahead == 'l') ADVANCE(79); + END_STATE(); + case 242: + if (lookahead == 'l') ADVANCE(241); + END_STATE(); + case 243: + if (lookahead == 'm') ADVANCE(435); + END_STATE(); + case 244: + if (lookahead == 'm') ADVANCE(436); + END_STATE(); + case 245: + if (lookahead == 'm') ADVANCE(498); + END_STATE(); + case 246: + if (lookahead == 'm') ADVANCE(283); + END_STATE(); + case 247: + if (lookahead == 'n') ADVANCE(181); + END_STATE(); + case 248: + if (lookahead == 'n') ADVANCE(328); + END_STATE(); + case 249: + if (lookahead == 'n') ADVANCE(468); + if (lookahead == 'p') ADVANCE(285); + if (lookahead == 't') ADVANCE(152); + END_STATE(); + case 250: + if (lookahead == 'n') ADVANCE(468); + if (lookahead == 't') ADVANCE(152); + END_STATE(); + case 251: + if (lookahead == 'n') ADVANCE(776); + END_STATE(); + case 252: + if (lookahead == 'n') ADVANCE(413); + END_STATE(); + case 253: + if (lookahead == 'n') ADVANCE(75); + END_STATE(); + case 254: + if (lookahead == 'n') ADVANCE(470); + if (lookahead == 't') ADVANCE(176); + END_STATE(); + case 255: + if (lookahead == 'n') ADVANCE(473); + END_STATE(); + case 256: + if (lookahead == 'n') ADVANCE(475); + END_STATE(); + case 257: + if (lookahead == 'n') ADVANCE(467); + if (lookahead == 'p') ADVANCE(285); + if (lookahead == 't') ADVANCE(179); + END_STATE(); + case 258: + if (lookahead == 'n') ADVANCE(472); + END_STATE(); + case 259: + if (lookahead == 'n') ADVANCE(333); + END_STATE(); + case 260: + if (lookahead == 'n') ADVANCE(77); + END_STATE(); + case 261: + if (lookahead == 'n') ADVANCE(112); + END_STATE(); + case 262: + if (lookahead == 'n') ADVANCE(379); + if (lookahead == 'r') ADVANCE(304); + END_STATE(); + case 263: + if (lookahead == 'n') ADVANCE(133); + END_STATE(); + case 264: + if (lookahead == 'n') ADVANCE(97); + END_STATE(); + case 265: + if (lookahead == 'n') ADVANCE(377); + if (lookahead == 'r') ADVANCE(308); + END_STATE(); + case 266: + if (lookahead == 'n') ADVANCE(113); + END_STATE(); + case 267: + if (lookahead == 'n') ADVANCE(338); + END_STATE(); + case 268: + if (lookahead == 'n') ADVANCE(125); + END_STATE(); + case 269: + if (lookahead == 'n') ADVANCE(114); + END_STATE(); + case 270: + if (lookahead == 'n') ADVANCE(350); + END_STATE(); + case 271: + if (lookahead == 'n') ADVANCE(344); + END_STATE(); + case 272: + if (lookahead == 'n') ADVANCE(321); + if (lookahead == 't') ADVANCE(178); + END_STATE(); + case 273: + if (lookahead == 'n') ADVANCE(324); + END_STATE(); + case 274: + if (lookahead == 'n') ADVANCE(306); + if (lookahead == 't') ADVANCE(180); + END_STATE(); + case 275: + if (lookahead == 'n') ADVANCE(317); + END_STATE(); + case 276: + if (lookahead == 'n') ADVANCE(351); + END_STATE(); + case 277: + if (lookahead == 'n') ADVANCE(134); + END_STATE(); + case 278: + if (lookahead == 'o') ADVANCE(124); + END_STATE(); + case 279: + if (lookahead == 'o') ADVANCE(118); + if (lookahead == 'u') ADVANCE(235); + END_STATE(); + case 280: + if (lookahead == 'o') ADVANCE(259); + END_STATE(); + case 281: + if (lookahead == 'o') ADVANCE(111); + END_STATE(); + case 282: + if (lookahead == 'o') ADVANCE(107); + END_STATE(); + case 283: + if (lookahead == 'o') ADVANCE(296); + END_STATE(); + case 284: + if (lookahead == 'o') ADVANCE(267); + END_STATE(); + case 285: + if (lookahead == 'o') ADVANCE(300); + END_STATE(); + case 286: + if (lookahead == 'o') ADVANCE(270); + END_STATE(); + case 287: + if (lookahead == 'o') ADVANCE(301); + END_STATE(); + case 288: + if (lookahead == 'o') ADVANCE(271); + END_STATE(); + case 289: + if (lookahead == 'o') ADVANCE(276); + END_STATE(); + case 290: + if (lookahead == 'p') ADVANCE(415); + END_STATE(); + case 291: + if (lookahead == 'p') ADVANCE(141); + END_STATE(); + case 292: + if (lookahead == 'p') ADVANCE(287); + END_STATE(); + case 293: + if (lookahead == 'q') ADVANCE(456); + if (lookahead == 'x') ADVANCE(250); + END_STATE(); + case 294: + if (lookahead == 'q') ADVANCE(298); + if (lookahead == 'x') ADVANCE(274); + END_STATE(); + case 295: + if (lookahead == 'r') ADVANCE(88); + END_STATE(); + case 296: + if (lookahead == 'r') ADVANCE(376); + END_STATE(); + case 297: + if (lookahead == 'r') ADVANCE(354); + END_STATE(); + case 298: + if (lookahead == 'r') ADVANCE(149); + END_STATE(); + case 299: + if (lookahead == 'r') ADVANCE(335); + END_STATE(); + case 300: + if (lookahead == 'r') ADVANCE(336); + END_STATE(); + case 301: + if (lookahead == 'r') ADVANCE(337); + END_STATE(); + case 302: + if (lookahead == 'r') ADVANCE(255); + END_STATE(); + case 303: + if (lookahead == 'r') ADVANCE(260); + END_STATE(); + case 304: + if (lookahead == 'r') ADVANCE(104); + END_STATE(); + case 305: + if (lookahead == 'r') ADVANCE(154); + END_STATE(); + case 306: + if (lookahead == 'r') ADVANCE(156); + END_STATE(); + case 307: + if (lookahead == 'r') ADVANCE(256); + END_STATE(); + case 308: + if (lookahead == 'r') ADVANCE(96); + END_STATE(); + case 309: + if (lookahead == 'r') ADVANCE(159); + END_STATE(); + case 310: + if (lookahead == 'r') ADVANCE(273); + END_STATE(); + case 311: + if (lookahead == 'r') ADVANCE(153); + END_STATE(); + case 312: + if (lookahead == 'r') ADVANCE(258); + END_STATE(); + case 313: + if (lookahead == 'r') ADVANCE(160); + END_STATE(); + case 314: + if (lookahead == 'r') ADVANCE(165); + END_STATE(); + case 315: + if (lookahead == 'r') ADVANCE(144); + END_STATE(); + case 316: + if (lookahead == 'r') ADVANCE(158); + END_STATE(); + case 317: + if (lookahead == 'r') ADVANCE(167); + END_STATE(); + case 318: + if (lookahead == 'r') ADVANCE(168); + END_STATE(); + case 319: + if (lookahead == 'r') ADVANCE(175); + END_STATE(); + case 320: + if (lookahead == 'r') ADVANCE(169); + END_STATE(); + case 321: + if (lookahead == 'r') ADVANCE(171); + END_STATE(); + case 322: + if (lookahead == 'r') ADVANCE(172); + END_STATE(); + case 323: + if (lookahead == 'r') ADVANCE(173); + END_STATE(); + case 324: + if (lookahead == 'r') ADVANCE(174); + END_STATE(); + case 325: + if (lookahead == 'r') ADVANCE(362); + END_STATE(); + case 326: + if (lookahead == 'r') ADVANCE(275); + END_STATE(); + case 327: + if (lookahead == 'r') ADVANCE(177); + END_STATE(); + case 328: + if (lookahead == 's') ADVANCE(208); + END_STATE(); + case 329: + if (lookahead == 's') ADVANCE(210); + END_STATE(); + case 330: + if (lookahead == 's') ADVANCE(162); + END_STATE(); + case 331: + if (lookahead == 's') ADVANCE(170); + END_STATE(); + case 332: + if (lookahead == 't') ADVANCE(450); + END_STATE(); + case 333: + if (lookahead == 't') ADVANCE(432); + END_STATE(); + case 334: + if (lookahead == 't') ADVANCE(75); + END_STATE(); + case 335: + if (lookahead == 't') ADVANCE(486); + END_STATE(); + case 336: + if (lookahead == 't') ADVANCE(441); + END_STATE(); + case 337: + if (lookahead == 't') ADVANCE(479); + END_STATE(); + case 338: + if (lookahead == 't') ADVANCE(477); + END_STATE(); + case 339: + if (lookahead == 't') ADVANCE(489); + END_STATE(); + case 340: + if (lookahead == 't') ADVANCE(533); + END_STATE(); + case 341: + if (lookahead == 't') ADVANCE(461); + END_STATE(); + case 342: + if (lookahead == 't') ADVANCE(419); + END_STATE(); + case 343: + if (lookahead == 't') ADVANCE(421); + END_STATE(); + case 344: + if (lookahead == 't') ADVANCE(431); + END_STATE(); + case 345: + if (lookahead == 't') ADVANCE(460); + END_STATE(); + case 346: + if (lookahead == 't') ADVANCE(86); + END_STATE(); + case 347: + if (lookahead == 't') ADVANCE(297); + END_STATE(); + case 348: + if (lookahead == 't') ADVANCE(116); + END_STATE(); + case 349: + if (lookahead == 't') ADVANCE(91); + END_STATE(); + case 350: + if (lookahead == 't') ADVANCE(322); + END_STATE(); + case 351: + if (lookahead == 't') ADVANCE(313); + END_STATE(); + case 352: + if (lookahead == 't') ADVANCE(318); + END_STATE(); + case 353: + if (lookahead == 't') ADVANCE(90); + if (lookahead == 'u') ADVANCE(105); + END_STATE(); + case 354: + if (lookahead == 'u') ADVANCE(120); + END_STATE(); + case 355: + if (lookahead == 'u') ADVANCE(232); + END_STATE(); + case 356: + if (lookahead == 'u') ADVANCE(266); + END_STATE(); + case 357: + if (lookahead == 'u') ADVANCE(303); + END_STATE(); + case 358: + if (lookahead == 'u') ADVANCE(237); + END_STATE(); + case 359: + if (lookahead == 'u') ADVANCE(268); + END_STATE(); + case 360: + if (lookahead == 'u') ADVANCE(234); + END_STATE(); + case 361: + if (lookahead == 'u') ADVANCE(269); + END_STATE(); + case 362: + if (lookahead == 'u') ADVANCE(127); + END_STATE(); + case 363: + if (lookahead == 'u') ADVANCE(123); + END_STATE(); + case 364: + if (lookahead == 'x') ADVANCE(254); + END_STATE(); + case 365: + if (lookahead == 'x') ADVANCE(48); + END_STATE(); + case 366: + if (lookahead == 'x') ADVANCE(72); + END_STATE(); + case 367: + if (lookahead == 'x') ADVANCE(392); + END_STATE(); + case 368: + if (lookahead == 'x') ADVANCE(272); + END_STATE(); + case 369: + if (lookahead == 'x') ADVANCE(54); + END_STATE(); + case 370: + if (lookahead == 'x') ADVANCE(63); + END_STATE(); + case 371: + if (lookahead == 'x') ADVANCE(55); + END_STATE(); + case 372: + if (lookahead == 'x') ADVANCE(64); + END_STATE(); + case 373: + if (lookahead == 'y') ADVANCE(452); + END_STATE(); + case 374: + if (lookahead == 'y') ADVANCE(78); + END_STATE(); + case 375: + if (lookahead == 'y') ADVANCE(402); + END_STATE(); + case 376: + if (lookahead == 'y') ADVANCE(446); + END_STATE(); + case 377: + if (lookahead == 'y') ADVANCE(451); + END_STATE(); + case 378: + if (lookahead == 'y') ADVANCE(401); + END_STATE(); + case 379: + if (lookahead == 'y') ADVANCE(305); + END_STATE(); + case 380: + if (lookahead == 'y') ADVANCE(314); + END_STATE(); + case 381: + if (lookahead == 'z') ADVANCE(145); + END_STATE(); + case 382: + if (lookahead == '+' || + lookahead == '-') ADVANCE(386); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(785); + END_STATE(); + case 383: + if (lookahead == '+' || + lookahead == '-') ADVANCE(387); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(778); + END_STATE(); + case 384: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 385: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(779); + END_STATE(); + case 386: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(785); + END_STATE(); + case 387: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(778); + END_STATE(); + case 388: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(809); + END_STATE(); + case 389: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(789); + END_STATE(); + case 390: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(774); + END_STATE(); + case 391: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(777); + END_STATE(); + case 392: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(780); + END_STATE(); + case 393: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(786); + END_STATE(); + case 394: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(810); + END_STATE(); + case 395: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(781); + END_STATE(); + case 396: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(811); + END_STATE(); + case 397: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 398: + ACCEPT_TOKEN(anon_sym_i32); + END_STATE(); + case 399: + ACCEPT_TOKEN(anon_sym_i64); + END_STATE(); + case 400: + ACCEPT_TOKEN(anon_sym_LPAREN); + if (lookahead == ';') ADVANCE(826); + if (lookahead == '@') ADVANCE(12); + END_STATE(); + case 401: + ACCEPT_TOKEN(anon_sym_array); + END_STATE(); + case 402: + ACCEPT_TOKEN(anon_sym_array); + if (lookahead == 'r') ADVANCE(165); + END_STATE(); + case 403: + ACCEPT_TOKEN(anon_sym_array); + if (lookahead == 'r') ADVANCE(610); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 404: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 405: + ACCEPT_TOKEN(anon_sym_block); + END_STATE(); + case 406: + ACCEPT_TOKEN(anon_sym_block); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 407: + ACCEPT_TOKEN(anon_sym_end); + END_STATE(); + case 408: + ACCEPT_TOKEN(anon_sym_end); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 409: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 410: + ACCEPT_TOKEN(anon_sym_if); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 411: + ACCEPT_TOKEN(anon_sym_else); + END_STATE(); + case 412: + ACCEPT_TOKEN(anon_sym_else); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 413: + ACCEPT_TOKEN(anon_sym_then); + END_STATE(); + case 414: + ACCEPT_TOKEN(anon_sym_then); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 415: + ACCEPT_TOKEN(anon_sym_loop); + END_STATE(); + case 416: + ACCEPT_TOKEN(anon_sym_loop); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 417: + ACCEPT_TOKEN(anon_sym_try_table); + END_STATE(); + case 418: + ACCEPT_TOKEN(anon_sym_try_table); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 419: + ACCEPT_TOKEN(anon_sym_call_indirect); + END_STATE(); + case 420: + ACCEPT_TOKEN(anon_sym_call_indirect); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 421: + ACCEPT_TOKEN(anon_sym_return_call_indirect); + END_STATE(); + case 422: + ACCEPT_TOKEN(anon_sym_return_call_indirect); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 423: + ACCEPT_TOKEN(anon_sym_catch); + if (lookahead == '_') ADVANCE(571); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 424: + ACCEPT_TOKEN(anon_sym_catch); + if (lookahead == '_') ADVANCE(100); + END_STATE(); + case 425: + ACCEPT_TOKEN(anon_sym_catch_ref); + END_STATE(); + case 426: + ACCEPT_TOKEN(anon_sym_catch_ref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 427: + ACCEPT_TOKEN(anon_sym_catch_all); + if (lookahead == '_') ADVANCE(320); + END_STATE(); + case 428: + ACCEPT_TOKEN(anon_sym_catch_all); + if (lookahead == '_') ADVANCE(732); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 429: + ACCEPT_TOKEN(anon_sym_catch_all_ref); + END_STATE(); + case 430: + ACCEPT_TOKEN(anon_sym_catch_all_ref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 431: + ACCEPT_TOKEN(anon_sym_cont); + END_STATE(); + case 432: + ACCEPT_TOKEN(anon_sym_cont); + if (lookahead == 'r') ADVANCE(160); + END_STATE(); + case 433: + ACCEPT_TOKEN(anon_sym_cont); + if (lookahead == 'r') ADVANCE(607); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 434: + ACCEPT_TOKEN(anon_sym_data); + END_STATE(); + case 435: + ACCEPT_TOKEN(anon_sym_elem); + END_STATE(); + case 436: + ACCEPT_TOKEN(anon_sym_item); + END_STATE(); + case 437: + ACCEPT_TOKEN(anon_sym_item); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 438: + ACCEPT_TOKEN(anon_sym_func); + END_STATE(); + case 439: + ACCEPT_TOKEN(anon_sym_func); + if (lookahead == 'r') ADVANCE(161); + END_STATE(); + case 440: + ACCEPT_TOKEN(anon_sym_func); + if (lookahead == 'r') ADVANCE(608); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 441: + ACCEPT_TOKEN(anon_sym_export); + END_STATE(); + case 442: + ACCEPT_TOKEN(anon_sym_export); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 443: + ACCEPT_TOKEN(anon_sym_global); + END_STATE(); + case 444: + ACCEPT_TOKEN(anon_sym_table); + END_STATE(); + case 445: + ACCEPT_TOKEN(anon_sym_table); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 446: + ACCEPT_TOKEN(anon_sym_memory); + END_STATE(); + case 447: + ACCEPT_TOKEN(anon_sym_memory); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 448: + ACCEPT_TOKEN(anon_sym_tag); + END_STATE(); + case 449: + ACCEPT_TOKEN(anon_sym_field); + END_STATE(); + case 450: + ACCEPT_TOKEN(anon_sym_mut); + END_STATE(); + case 451: + ACCEPT_TOKEN(anon_sym_any); + END_STATE(); + case 452: + ACCEPT_TOKEN(anon_sym_any); + if (lookahead == 'r') ADVANCE(154); + END_STATE(); + case 453: + ACCEPT_TOKEN(anon_sym_any); + if (lookahead == 'r') ADVANCE(604); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 454: + ACCEPT_TOKEN(anon_sym_eq); + END_STATE(); + case 455: + ACCEPT_TOKEN(anon_sym_eq); + if (lookahead == 'r') ADVANCE(602); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 456: + ACCEPT_TOKEN(anon_sym_eq); + if (lookahead == 'r') ADVANCE(149); + END_STATE(); + case 457: + ACCEPT_TOKEN(anon_sym_i31); + END_STATE(); + case 458: + ACCEPT_TOKEN(anon_sym_i31); + if (lookahead == 'r') ADVANCE(593); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 459: + ACCEPT_TOKEN(anon_sym_i31); + if (lookahead == 'r') ADVANCE(159); + END_STATE(); + case 460: + ACCEPT_TOKEN(anon_sym_struct); + END_STATE(); + case 461: + ACCEPT_TOKEN(anon_sym_struct); + if (lookahead == 'r') ADVANCE(168); + END_STATE(); + case 462: + ACCEPT_TOKEN(anon_sym_struct); + if (lookahead == 'r') ADVANCE(612); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 463: + ACCEPT_TOKEN(anon_sym_none); + END_STATE(); + case 464: + ACCEPT_TOKEN(anon_sym_none); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 465: + ACCEPT_TOKEN(anon_sym_nofunc); + END_STATE(); + case 466: + ACCEPT_TOKEN(anon_sym_nofunc); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 467: + ACCEPT_TOKEN(anon_sym_exn); + END_STATE(); + case 468: + ACCEPT_TOKEN(anon_sym_exn); + if (lookahead == 'r') ADVANCE(156); + END_STATE(); + case 469: + ACCEPT_TOKEN(anon_sym_exn); + if (lookahead == 'r') ADVANCE(605); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 470: + ACCEPT_TOKEN(anon_sym_noexn); + END_STATE(); + case 471: + ACCEPT_TOKEN(anon_sym_noexn); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 472: + ACCEPT_TOKEN(anon_sym_extern); + END_STATE(); + case 473: + ACCEPT_TOKEN(anon_sym_extern); + if (lookahead == 'r') ADVANCE(167); + END_STATE(); + case 474: + ACCEPT_TOKEN(anon_sym_extern); + if (lookahead == 'r') ADVANCE(611); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 475: + ACCEPT_TOKEN(anon_sym_noextern); + END_STATE(); + case 476: + ACCEPT_TOKEN(anon_sym_noextern); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 477: + ACCEPT_TOKEN(anon_sym_nocont); + END_STATE(); + case 478: + ACCEPT_TOKEN(anon_sym_nocont); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 479: + ACCEPT_TOKEN(anon_sym_import); + END_STATE(); + case 480: + ACCEPT_TOKEN(anon_sym_import); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 481: + ACCEPT_TOKEN(anon_sym_local); + END_STATE(); + case 482: + ACCEPT_TOKEN(anon_sym_local); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 483: + ACCEPT_TOKEN(anon_sym_pagesize); + END_STATE(); + case 484: + ACCEPT_TOKEN(anon_sym_module); + END_STATE(); + case 485: + ACCEPT_TOKEN(anon_sym_declare); + END_STATE(); + case 486: + ACCEPT_TOKEN(anon_sym_start); + END_STATE(); + case 487: + ACCEPT_TOKEN(anon_sym_f32); + END_STATE(); + case 488: + ACCEPT_TOKEN(anon_sym_f64); + END_STATE(); + case 489: + ACCEPT_TOKEN(anon_sym_offset); + if (lookahead == '=') ADVANCE(41); + END_STATE(); + case 490: + ACCEPT_TOKEN(anon_sym_offset); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 491: + ACCEPT_TOKEN(anon_sym_on); + END_STATE(); + case 492: + ACCEPT_TOKEN(anon_sym_on); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 493: + ACCEPT_TOKEN(anon_sym_switch); + END_STATE(); + case 494: + ACCEPT_TOKEN(anon_sym_i8); + END_STATE(); + case 495: + ACCEPT_TOKEN(anon_sym_i8); + if (lookahead == 'x') ADVANCE(48); + END_STATE(); + case 496: + ACCEPT_TOKEN(anon_sym_i16); + END_STATE(); + case 497: + ACCEPT_TOKEN(anon_sym_i16); + if (lookahead == 'x') ADVANCE(72); + END_STATE(); + case 498: + ACCEPT_TOKEN(anon_sym_param); + END_STATE(); + case 499: + ACCEPT_TOKEN(anon_sym_param); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 500: + ACCEPT_TOKEN(anon_sym_rec); + END_STATE(); + case 501: + ACCEPT_TOKEN(anon_sym_anyref); + END_STATE(); + case 502: + ACCEPT_TOKEN(anon_sym_anyref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 503: + ACCEPT_TOKEN(anon_sym_eqref); + END_STATE(); + case 504: + ACCEPT_TOKEN(anon_sym_eqref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 505: + ACCEPT_TOKEN(anon_sym_i31ref); + END_STATE(); + case 506: + ACCEPT_TOKEN(anon_sym_i31ref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 507: + ACCEPT_TOKEN(anon_sym_structref); + END_STATE(); + case 508: + ACCEPT_TOKEN(anon_sym_structref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 509: + ACCEPT_TOKEN(anon_sym_arrayref); + END_STATE(); + case 510: + ACCEPT_TOKEN(anon_sym_arrayref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 511: + ACCEPT_TOKEN(anon_sym_nullref); + END_STATE(); + case 512: + ACCEPT_TOKEN(anon_sym_nullref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 513: + ACCEPT_TOKEN(anon_sym_funcref); + END_STATE(); + case 514: + ACCEPT_TOKEN(anon_sym_funcref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 515: + ACCEPT_TOKEN(anon_sym_nullfuncref); + END_STATE(); + case 516: + ACCEPT_TOKEN(anon_sym_nullfuncref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 517: + ACCEPT_TOKEN(anon_sym_exnref); + END_STATE(); + case 518: + ACCEPT_TOKEN(anon_sym_exnref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 519: + ACCEPT_TOKEN(anon_sym_nullexnref); + END_STATE(); + case 520: + ACCEPT_TOKEN(anon_sym_nullexnref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 521: + ACCEPT_TOKEN(anon_sym_externref); + END_STATE(); + case 522: + ACCEPT_TOKEN(anon_sym_externref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 523: + ACCEPT_TOKEN(anon_sym_nullexternref); + END_STATE(); + case 524: + ACCEPT_TOKEN(anon_sym_nullexternref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 525: + ACCEPT_TOKEN(anon_sym_contref); + END_STATE(); + case 526: + ACCEPT_TOKEN(anon_sym_contref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 527: + ACCEPT_TOKEN(anon_sym_nullcontref); + END_STATE(); + case 528: + ACCEPT_TOKEN(anon_sym_nullcontref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 529: + ACCEPT_TOKEN(anon_sym_ref); + END_STATE(); + case 530: + ACCEPT_TOKEN(anon_sym_ref); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 531: + ACCEPT_TOKEN(anon_sym_null); + END_STATE(); + case 532: + ACCEPT_TOKEN(anon_sym_null); + if (lookahead == 'r') ADVANCE(163); + END_STATE(); + case 533: + ACCEPT_TOKEN(anon_sym_result); + END_STATE(); + case 534: + ACCEPT_TOKEN(anon_sym_result); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 535: + ACCEPT_TOKEN(anon_sym_sub); + END_STATE(); + case 536: + ACCEPT_TOKEN(anon_sym_final); + END_STATE(); + case 537: + ACCEPT_TOKEN(anon_sym_type); + END_STATE(); + case 538: + ACCEPT_TOKEN(anon_sym_type); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 539: + ACCEPT_TOKEN(sym_vec_type); + END_STATE(); + case 540: + ACCEPT_TOKEN(sym_identifier); + END_STATE(); + case 541: + ACCEPT_TOKEN(sym_identifier); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(541); + END_STATE(); + case 542: + ACCEPT_TOKEN(sym_instr_name); + ADVANCE_MAP( + '1', 554, + '3', 543, + '6', 552, + '8', 757, + 'f', 410, + 'n', 625, + '.', 771, + '0', 771, + '2', 771, + '4', 771, + '5', 771, + '7', 771, + '9', 771, + ); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 543: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '1') ADVANCE(458); + if (lookahead == '2') ADVANCE(764); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 544: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '1') ADVANCE(553); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 545: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '2') ADVANCE(803); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 546: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '2') ADVANCE(799); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 547: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '2') ADVANCE(761); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 548: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '3') ADVANCE(547); + if (lookahead == '6') ADVANCE(551); + if (lookahead == 'u') ADVANCE(691); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 549: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '4') ADVANCE(801); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 550: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '4') ADVANCE(797); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 551: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '4') ADVANCE(760); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 552: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '4') ADVANCE(763); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 553: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '6') ADVANCE(793); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 554: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '6') ADVANCE(758); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 555: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '8') ADVANCE(795); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 556: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == ':') ADVANCE(42); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 557: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '=') ADVANCE(41); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 558: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '_') ADVANCE(656); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 559: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '_') ADVANCE(748); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 560: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '_') ADVANCE(580); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 561: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '_') ADVANCE(658); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 562: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(574); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 563: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(668); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 564: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(677); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 565: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(669); + if (lookahead == 'o') ADVANCE(692); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 566: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(669); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 567: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(768); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 568: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(683); + if (lookahead == 'o') ADVANCE(581); + if (lookahead == 'u') ADVANCE(670); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 569: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(722); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 570: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(665); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 571: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(672); + if (lookahead == 'r') ADVANCE(619); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 572: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(575); + if (lookahead == 'r') ADVANCE(767); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 573: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'a') ADVANCE(676); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 574: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'b') ADVANCE(671); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 575: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'b') ADVANCE(674); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 576: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(659); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 577: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(440); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 578: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(466); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 579: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(651); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 580: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(573); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 581: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(708); + if (lookahead == 'e') ADVANCE(759); + if (lookahead == 'f') ADVANCE(754); + if (lookahead == 'n') ADVANCE(592); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 582: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(706); + if (lookahead == 'e') ADVANCE(762); + if (lookahead == 'f') ADVANCE(756); + if (lookahead == 'r') ADVANCE(609); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 583: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(741); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 584: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(570); + if (lookahead == 'o') ADVANCE(710); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 585: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(742); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 586: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(743); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 587: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'c') ADVANCE(730); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 588: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'd') ADVANCE(408); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 589: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'd') ADVANCE(655); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 590: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'd') ADVANCE(657); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 591: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(412); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 592: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(464); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 593: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(632); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 594: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(418); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 595: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(735); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 596: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(538); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 597: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(645); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 598: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(445); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 599: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(749); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 600: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(679); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 601: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(678); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 602: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(629); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 603: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(720); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 604: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(630); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 605: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(631); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 606: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(739); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 607: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(633); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 608: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(634); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 609: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(635); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 610: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(636); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 611: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(637); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 612: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(638); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 613: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(688); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 614: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(639); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 615: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(747); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 616: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(640); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 617: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(641); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 618: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(642); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 619: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(643); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 620: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(644); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 621: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(585); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 622: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(586); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 623: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(724); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 624: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'e') ADVANCE(725); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 625: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(770); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 626: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(410); + if (lookahead == 'm') ADVANCE(713); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 627: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(410); + if (lookahead == 't') ADVANCE(601); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 628: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(410); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 629: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(504); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 630: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(502); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 631: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(518); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 632: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(506); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 633: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(526); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 634: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(514); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 635: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(512); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 636: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(510); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 637: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(522); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 638: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(508); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 639: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(520); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 640: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(528); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 641: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(516); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 642: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(524); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 643: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(426); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 644: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(430); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 645: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(530); + if (lookahead == 't') ADVANCE(755); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 646: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(736); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 647: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(646); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 648: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(737); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 649: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'f') ADVANCE(648); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 650: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'g') ADVANCE(684); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 651: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'h') ADVANCE(423); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 652: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'h') ADVANCE(613); + if (lookahead == 'r') ADVANCE(767); + if (lookahead == 'y') ADVANCE(712); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 653: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'h') ADVANCE(613); + if (lookahead == 'r') ADVANCE(767); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 654: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'i') ADVANCE(650); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 655: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'i') ADVANCE(723); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 656: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'i') ADVANCE(690); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 657: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'i') ADVANCE(733); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 658: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'i') ADVANCE(700); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 659: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'k') ADVANCE(406); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 660: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(654); + if (lookahead == 'n') ADVANCE(766); + if (lookahead == 'r') ADVANCE(715); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 661: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(734); + if (lookahead == 'n') ADVANCE(588); + if (lookahead == 'q') ADVANCE(455); + if (lookahead == 'x') ADVANCE(682); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 662: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(734); + if (lookahead == 'n') ADVANCE(588); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 663: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(582); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 664: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(428); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 665: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(482); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 666: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(701); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 667: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(558); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 668: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(667); + if (lookahead == 't') ADVANCE(579); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 669: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(667); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 670: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(663); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 671: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(594); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 672: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(664); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 673: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(744); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 674: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(598); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 675: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(561); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 676: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'l') ADVANCE(675); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 677: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'm') ADVANCE(499); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 678: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'm') ADVANCE(437); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 679: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'm') ADVANCE(707); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 680: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(588); + if (lookahead == 'q') ADVANCE(455); + if (lookahead == 'x') ADVANCE(682); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 681: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(588); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 682: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(469); + if (lookahead == 't') ADVANCE(603); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 683: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(556); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 684: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(557); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 685: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(471); + if (lookahead == 't') ADVANCE(623); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 686: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(474); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 687: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(476); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 688: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(414); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 689: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(492); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 690: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(589); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 691: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(577); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 692: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(738); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 693: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(560); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 694: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 695: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(740); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 696: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(728); + if (lookahead == 't') ADVANCE(624); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 697: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(587); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 698: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(751); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 699: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(731); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 700: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'n') ADVANCE(590); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 701: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(576); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 702: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(710); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 703: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(584); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 704: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(702); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 705: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(726); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 706: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(698); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 707: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(719); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 708: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(695); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 709: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'o') ADVANCE(727); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 710: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'p') ADVANCE(416); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 711: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'p') ADVANCE(705); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 712: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'p') ADVANCE(596); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 713: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'p') ADVANCE(709); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 714: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'q') ADVANCE(455); + if (lookahead == 'x') ADVANCE(682); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 715: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(567); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 716: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(767); + if (lookahead == 'y') ADVANCE(712); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 717: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(767); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 718: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(752); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 719: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(769); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 720: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(686); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 721: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(693); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 722: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(564); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 723: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(621); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 724: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(687); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 725: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(699); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 726: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(745); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 727: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(746); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 728: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(614); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 729: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(616); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 730: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(617); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 731: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(618); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 732: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(620); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 733: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'r') ADVANCE(622); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 734: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 's') ADVANCE(591); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 735: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 's') ADVANCE(753); + if (lookahead == 't') ADVANCE(755); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 736: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 's') ADVANCE(606); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 737: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 's') ADVANCE(615); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 738: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(433); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 739: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(557); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 740: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(478); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 741: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(462); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 742: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(420); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 743: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(422); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 744: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(534); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 745: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(442); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 746: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(480); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 747: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(490); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 748: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(562); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 749: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(755); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 750: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(718); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 751: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 't') ADVANCE(729); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 752: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'u') ADVANCE(583); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 753: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'u') ADVANCE(673); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 754: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'u') ADVANCE(694); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 755: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'u') ADVANCE(721); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 756: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'u') ADVANCE(697); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 757: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(544); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 758: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(555); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 759: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(685); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 760: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(545); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 761: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(549); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 762: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(696); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 763: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(546); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 764: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(550); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 765: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'x') ADVANCE(711); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 766: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'y') ADVANCE(453); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 767: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'y') ADVANCE(559); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 768: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'y') ADVANCE(403); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 769: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == 'y') ADVANCE(447); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 770: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9')) ADVANCE(771); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(770); + END_STATE(); + case 771: + ACCEPT_TOKEN(sym_instr_name); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 772: + ACCEPT_TOKEN(sym_integer); + if (lookahead == '.') ADVANCE(782); + if (lookahead == '_') ADVANCE(384); + if (lookahead == 'x') ADVANCE(390); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(382); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 773: + ACCEPT_TOKEN(sym_integer); + if (lookahead == '.') ADVANCE(782); + if (lookahead == '_') ADVANCE(384); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(382); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(773); + END_STATE(); + case 774: + ACCEPT_TOKEN(sym_integer); + if (lookahead == '.') ADVANCE(783); + if (lookahead == '_') ADVANCE(390); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(382); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(774); + END_STATE(); + case 775: + ACCEPT_TOKEN(aux_sym_float_token1); + END_STATE(); + case 776: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == ':') ADVANCE(42); + END_STATE(); + case 777: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == '_') ADVANCE(391); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(777); + END_STATE(); + case 778: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == '_') ADVANCE(387); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(778); + END_STATE(); + case 779: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == '_') ADVANCE(385); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(779); + END_STATE(); + case 780: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == '_') ADVANCE(395); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(780); + END_STATE(); + case 781: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == '_') ADVANCE(395); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(784); + END_STATE(); + case 782: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(779); + END_STATE(); + case 783: + ACCEPT_TOKEN(aux_sym_float_token1); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(777); + END_STATE(); + case 784: + ACCEPT_TOKEN(aux_sym_float_token1); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(784); + END_STATE(); + case 785: + ACCEPT_TOKEN(aux_sym_float_token2); + if (lookahead == '_') ADVANCE(386); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(785); + END_STATE(); + case 786: + ACCEPT_TOKEN(sym_mem_arg); + if (lookahead == '_') ADVANCE(393); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(791); + END_STATE(); + case 787: + ACCEPT_TOKEN(sym_mem_arg); + if (lookahead == '_') ADVANCE(389); + if (lookahead == 'x') ADVANCE(393); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(790); + END_STATE(); + case 788: + ACCEPT_TOKEN(sym_mem_arg); + if (lookahead == '_') ADVANCE(389); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(790); + END_STATE(); + case 789: + ACCEPT_TOKEN(sym_mem_arg); + if (lookahead == '_') ADVANCE(389); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(789); + END_STATE(); + case 790: + ACCEPT_TOKEN(sym_mem_arg); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(790); + END_STATE(); + case 791: + ACCEPT_TOKEN(sym_mem_arg); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(791); + END_STATE(); + case 792: + ACCEPT_TOKEN(anon_sym_i8x16); + END_STATE(); + case 793: + ACCEPT_TOKEN(anon_sym_i8x16); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 794: + ACCEPT_TOKEN(anon_sym_i16x8); + END_STATE(); + case 795: + ACCEPT_TOKEN(anon_sym_i16x8); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 796: + ACCEPT_TOKEN(anon_sym_i32x4); + END_STATE(); + case 797: + ACCEPT_TOKEN(anon_sym_i32x4); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 798: + ACCEPT_TOKEN(anon_sym_i64x2); + END_STATE(); + case 799: + ACCEPT_TOKEN(anon_sym_i64x2); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 800: + ACCEPT_TOKEN(anon_sym_f32x4); + END_STATE(); + case 801: + ACCEPT_TOKEN(anon_sym_f32x4); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 802: + ACCEPT_TOKEN(anon_sym_f64x2); + END_STATE(); + case 803: + ACCEPT_TOKEN(anon_sym_f64x2); + if (lookahead == '.' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z') || + lookahead == 0x17f || + lookahead == 0x212a) ADVANCE(771); + END_STATE(); + case 804: + ACCEPT_TOKEN(anon_sym_shared); + END_STATE(); + case 805: + ACCEPT_TOKEN(anon_sym_unshared); + END_STATE(); + case 806: + ACCEPT_TOKEN(sym_string); + END_STATE(); + case 807: + ACCEPT_TOKEN(sym_string); + if (lookahead == '"') ADVANCE(806); + if (lookahead == '\\') ADVANCE(8); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(6); + END_STATE(); + case 808: + ACCEPT_TOKEN(sym_uinteger); + if (lookahead == '_') ADVANCE(388); + if (lookahead == 'x') ADVANCE(394); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(809); + END_STATE(); + case 809: + ACCEPT_TOKEN(sym_uinteger); + if (lookahead == '_') ADVANCE(388); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(809); + END_STATE(); + case 810: + ACCEPT_TOKEN(sym_uinteger); + if (lookahead == '_') ADVANCE(396); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(810); + END_STATE(); + case 811: + ACCEPT_TOKEN(sym_uinteger); + if (lookahead == '_') ADVANCE(396); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(812); + END_STATE(); + case 812: + ACCEPT_TOKEN(sym_uinteger); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(812); + END_STATE(); + case 813: + ACCEPT_TOKEN(sym_annotation_start); + END_STATE(); + case 814: + ACCEPT_TOKEN(sym_annotation_start); + if (lookahead == '"') ADVANCE(813); + if (lookahead == '\\') ADVANCE(11); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(10); + END_STATE(); + case 815: + ACCEPT_TOKEN(sym_annotation_start); + if (lookahead == '"') ADVANCE(818); + if (lookahead == '\\') ADVANCE(821); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ' || + lookahead == ')') ADVANCE(10); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(820); + END_STATE(); + case 816: + ACCEPT_TOKEN(sym_annotation_start); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(816); + END_STATE(); + case 817: + ACCEPT_TOKEN(sym_annotation_start); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(817); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != '!' && + (lookahead < ')' || ':' < lookahead)) ADVANCE(825); + END_STATE(); + case 818: + ACCEPT_TOKEN(sym_annotation_start); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ')') ADVANCE(825); + END_STATE(); + case 819: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == '"') ADVANCE(820); + if (set_contains(sym_identifier_character_set_2, 10, lookahead)) ADVANCE(817); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + (lookahead < ' ' || '\'' < lookahead) && + (lookahead < ')' || ':' < lookahead)) ADVANCE(825); + END_STATE(); + case 820: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == '"') ADVANCE(818); + if (lookahead == '\\') ADVANCE(821); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ' || + lookahead == ')') ADVANCE(10); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(820); + END_STATE(); + case 821: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == '"') ADVANCE(815); + if (lookahead == '\\') ADVANCE(821); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ' || + lookahead == ')') ADVANCE(10); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(820); + END_STATE(); + case 822: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == ';') ADVANCE(827); + if (lookahead == '@') ADVANCE(819); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ')') ADVANCE(825); + END_STATE(); + case 823: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == ';') ADVANCE(824); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ')') ADVANCE(825); + END_STATE(); + case 824: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ' || + lookahead == ')') ADVANCE(829); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(824); + END_STATE(); + case 825: + ACCEPT_TOKEN(sym_annotation_elem); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ')') ADVANCE(825); + END_STATE(); + case 826: + ACCEPT_TOKEN(anon_sym_LPAREN_SEMI); + END_STATE(); + case 827: + ACCEPT_TOKEN(anon_sym_LPAREN_SEMI); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ')') ADVANCE(825); + END_STATE(); + case 828: + ACCEPT_TOKEN(anon_sym_SEMI_RPAREN); + END_STATE(); + case 829: + ACCEPT_TOKEN(sym_line_comment); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(829); + END_STATE(); + default: + return false; + } +} + +static const TSLexerMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 0}, + [2] = {.lex_state = 1}, + [3] = {.lex_state = 4}, + [4] = {.lex_state = 1}, + [5] = {.lex_state = 4}, + [6] = {.lex_state = 1}, + [7] = {.lex_state = 1}, + [8] = {.lex_state = 1}, + [9] = {.lex_state = 4}, + [10] = {.lex_state = 1}, + [11] = {.lex_state = 1}, + [12] = {.lex_state = 1}, + [13] = {.lex_state = 5}, + [14] = {.lex_state = 2}, + [15] = {.lex_state = 2}, + [16] = {.lex_state = 5}, + [17] = {.lex_state = 5}, + [18] = {.lex_state = 2}, + [19] = {.lex_state = 1}, + [20] = {.lex_state = 4}, + [21] = {.lex_state = 4}, + [22] = {.lex_state = 4}, + [23] = {.lex_state = 4}, + [24] = {.lex_state = 4}, + [25] = {.lex_state = 4}, + [26] = {.lex_state = 4}, + [27] = {.lex_state = 4}, + [28] = {.lex_state = 4}, + [29] = {.lex_state = 4}, + [30] = {.lex_state = 4}, + [31] = {.lex_state = 5}, + [32] = {.lex_state = 2}, + [33] = {.lex_state = 2}, + [34] = {.lex_state = 5}, + [35] = {.lex_state = 5}, + [36] = {.lex_state = 5}, + [37] = {.lex_state = 5}, + [38] = {.lex_state = 5}, + [39] = {.lex_state = 2}, + [40] = {.lex_state = 2}, + [41] = {.lex_state = 2}, + [42] = {.lex_state = 5}, + [43] = {.lex_state = 5}, + [44] = {.lex_state = 2}, + [45] = {.lex_state = 2}, + [46] = {.lex_state = 2}, + [47] = {.lex_state = 2}, + [48] = {.lex_state = 5}, + [49] = {.lex_state = 5}, + [50] = {.lex_state = 5}, + [51] = {.lex_state = 2}, + [52] = {.lex_state = 2}, + [53] = {.lex_state = 1}, + [54] = {.lex_state = 1}, + [55] = {.lex_state = 1}, + [56] = {.lex_state = 1}, + [57] = {.lex_state = 1}, + [58] = {.lex_state = 1}, + [59] = {.lex_state = 1}, + [60] = {.lex_state = 1}, + [61] = {.lex_state = 1}, + [62] = {.lex_state = 1}, + [63] = {.lex_state = 1}, + [64] = {.lex_state = 13}, + [65] = {.lex_state = 3}, + [66] = {.lex_state = 13}, + [67] = {.lex_state = 13}, + [68] = {.lex_state = 13}, + [69] = {.lex_state = 3}, + [70] = {.lex_state = 14}, + [71] = {.lex_state = 14}, + [72] = {.lex_state = 14}, + [73] = {.lex_state = 15}, + [74] = {.lex_state = 13}, + [75] = {.lex_state = 3}, + [76] = {.lex_state = 15}, + [77] = {.lex_state = 13}, + [78] = {.lex_state = 14}, + [79] = {.lex_state = 13}, + [80] = {.lex_state = 15}, + [81] = {.lex_state = 13}, + [82] = {.lex_state = 14}, + [83] = {.lex_state = 14}, + [84] = {.lex_state = 13}, + [85] = {.lex_state = 14}, + [86] = {.lex_state = 14}, + [87] = {.lex_state = 15}, + [88] = {.lex_state = 13}, + [89] = {.lex_state = 13}, + [90] = {.lex_state = 14}, + [91] = {.lex_state = 14}, + [92] = {.lex_state = 14}, + [93] = {.lex_state = 14}, + [94] = {.lex_state = 3}, + [95] = {.lex_state = 14}, + [96] = {.lex_state = 13}, + [97] = {.lex_state = 15}, + [98] = {.lex_state = 14}, + [99] = {.lex_state = 14}, + [100] = {.lex_state = 15}, + [101] = {.lex_state = 13}, + [102] = {.lex_state = 3}, + [103] = {.lex_state = 14}, + [104] = {.lex_state = 14}, + [105] = {.lex_state = 14}, + [106] = {.lex_state = 14}, + [107] = {.lex_state = 14}, + [108] = {.lex_state = 13}, + [109] = {.lex_state = 14}, + [110] = {.lex_state = 13}, + [111] = {.lex_state = 13}, + [112] = {.lex_state = 13}, + [113] = {.lex_state = 15}, + [114] = {.lex_state = 15}, + [115] = {.lex_state = 13}, + [116] = {.lex_state = 13}, + [117] = {.lex_state = 13}, + [118] = {.lex_state = 13}, + [119] = {.lex_state = 15}, + [120] = {.lex_state = 15}, + [121] = {.lex_state = 13}, + [122] = {.lex_state = 13}, + [123] = {.lex_state = 13}, + [124] = {.lex_state = 15}, + [125] = {.lex_state = 15}, + [126] = {.lex_state = 13}, + [127] = {.lex_state = 13}, + [128] = {.lex_state = 13}, + [129] = {.lex_state = 15}, + [130] = {.lex_state = 15}, + [131] = {.lex_state = 13}, + [132] = {.lex_state = 13}, + [133] = {.lex_state = 13}, + [134] = {.lex_state = 15}, + [135] = {.lex_state = 15}, + [136] = {.lex_state = 13}, + [137] = {.lex_state = 13}, + [138] = {.lex_state = 13}, + [139] = {.lex_state = 15}, + [140] = {.lex_state = 15}, + [141] = {.lex_state = 13}, + [142] = {.lex_state = 13}, + [143] = {.lex_state = 15}, + [144] = {.lex_state = 15}, + [145] = {.lex_state = 15}, + [146] = {.lex_state = 15}, + [147] = {.lex_state = 13}, + [148] = {.lex_state = 13}, + [149] = {.lex_state = 13}, + [150] = {.lex_state = 13}, + [151] = {.lex_state = 15}, + [152] = {.lex_state = 15}, + [153] = {.lex_state = 13}, + [154] = {.lex_state = 13}, + [155] = {.lex_state = 13}, + [156] = {.lex_state = 15}, + [157] = {.lex_state = 15}, + [158] = {.lex_state = 13}, + [159] = {.lex_state = 13}, + [160] = {.lex_state = 15}, + [161] = {.lex_state = 13}, + [162] = {.lex_state = 13}, + [163] = {.lex_state = 13}, + [164] = {.lex_state = 13}, + [165] = {.lex_state = 13}, + [166] = {.lex_state = 13}, + [167] = {.lex_state = 13}, + [168] = {.lex_state = 13}, + [169] = {.lex_state = 13}, + [170] = {.lex_state = 13}, + [171] = {.lex_state = 13}, + [172] = {.lex_state = 13}, + [173] = {.lex_state = 13}, + [174] = {.lex_state = 15}, + [175] = {.lex_state = 13}, + [176] = {.lex_state = 13}, + [177] = {.lex_state = 14}, + [178] = {.lex_state = 15}, + [179] = {.lex_state = 13}, + [180] = {.lex_state = 14}, + [181] = {.lex_state = 14}, + [182] = {.lex_state = 14}, + [183] = {.lex_state = 13}, + [184] = {.lex_state = 13}, + [185] = {.lex_state = 14}, + [186] = {.lex_state = 14}, + [187] = {.lex_state = 14}, + [188] = {.lex_state = 14}, + [189] = {.lex_state = 3}, + [190] = {.lex_state = 13}, + [191] = {.lex_state = 14}, + [192] = {.lex_state = 13}, + [193] = {.lex_state = 13}, + [194] = {.lex_state = 13}, + [195] = {.lex_state = 15}, + [196] = {.lex_state = 3}, + [197] = {.lex_state = 3}, + [198] = {.lex_state = 15}, + [199] = {.lex_state = 14}, + [200] = {.lex_state = 14}, + [201] = {.lex_state = 15}, + [202] = {.lex_state = 13}, + [203] = {.lex_state = 15}, + [204] = {.lex_state = 13}, + [205] = {.lex_state = 14}, + [206] = {.lex_state = 15}, + [207] = {.lex_state = 13}, + [208] = {.lex_state = 13}, + [209] = {.lex_state = 13}, + [210] = {.lex_state = 15}, + [211] = {.lex_state = 13}, + [212] = {.lex_state = 15}, + [213] = {.lex_state = 3}, + [214] = {.lex_state = 13}, + [215] = {.lex_state = 15}, + [216] = {.lex_state = 13}, + [217] = {.lex_state = 15}, + [218] = {.lex_state = 13}, + [219] = {.lex_state = 13}, + [220] = {.lex_state = 13}, + [221] = {.lex_state = 13}, + [222] = {.lex_state = 15}, + [223] = {.lex_state = 15}, + [224] = {.lex_state = 13}, + [225] = {.lex_state = 13}, + [226] = {.lex_state = 15}, + [227] = {.lex_state = 13}, + [228] = {.lex_state = 13}, + [229] = {.lex_state = 13}, + [230] = {.lex_state = 3}, + [231] = {.lex_state = 15}, + [232] = {.lex_state = 13}, + [233] = {.lex_state = 13}, + [234] = {.lex_state = 15}, + [235] = {.lex_state = 15}, + [236] = {.lex_state = 13}, + [237] = {.lex_state = 3}, + [238] = {.lex_state = 13}, + [239] = {.lex_state = 15}, + [240] = {.lex_state = 15}, + [241] = {.lex_state = 15}, + [242] = {.lex_state = 15}, + [243] = {.lex_state = 13}, + [244] = {.lex_state = 13}, + [245] = {.lex_state = 15}, + [246] = {.lex_state = 13}, + [247] = {.lex_state = 13}, + [248] = {.lex_state = 13}, + [249] = {.lex_state = 13}, + [250] = {.lex_state = 13}, + [251] = {.lex_state = 13}, + [252] = {.lex_state = 13}, + [253] = {.lex_state = 13}, + [254] = {.lex_state = 15}, + [255] = {.lex_state = 13}, + [256] = {.lex_state = 13}, + [257] = {.lex_state = 15}, + [258] = {.lex_state = 15}, + [259] = {.lex_state = 13}, + [260] = {.lex_state = 15}, + [261] = {.lex_state = 15}, + [262] = {.lex_state = 15}, + [263] = {.lex_state = 15}, + [264] = {.lex_state = 13}, + [265] = {.lex_state = 13}, + [266] = {.lex_state = 15}, + [267] = {.lex_state = 13}, + [268] = {.lex_state = 13}, + [269] = {.lex_state = 13}, + [270] = {.lex_state = 13}, + [271] = {.lex_state = 15}, + [272] = {.lex_state = 15}, + [273] = {.lex_state = 13}, + [274] = {.lex_state = 15}, + [275] = {.lex_state = 13}, + [276] = {.lex_state = 13}, + [277] = {.lex_state = 15}, + [278] = {.lex_state = 13}, + [279] = {.lex_state = 15}, + [280] = {.lex_state = 13}, + [281] = {.lex_state = 13}, + [282] = {.lex_state = 15}, + [283] = {.lex_state = 13}, + [284] = {.lex_state = 13}, + [285] = {.lex_state = 15}, + [286] = {.lex_state = 13}, + [287] = {.lex_state = 13}, + [288] = {.lex_state = 15}, + [289] = {.lex_state = 15}, + [290] = {.lex_state = 15}, + [291] = {.lex_state = 13}, + [292] = {.lex_state = 13}, + [293] = {.lex_state = 13}, + [294] = {.lex_state = 13}, + [295] = {.lex_state = 13}, + [296] = {.lex_state = 13}, + [297] = {.lex_state = 13}, + [298] = {.lex_state = 15}, + [299] = {.lex_state = 13}, + [300] = {.lex_state = 15}, + [301] = {.lex_state = 13}, + [302] = {.lex_state = 13}, + [303] = {.lex_state = 15}, + [304] = {.lex_state = 13}, + [305] = {.lex_state = 13}, + [306] = {.lex_state = 15}, + [307] = {.lex_state = 13}, + [308] = {.lex_state = 13}, + [309] = {.lex_state = 13}, + [310] = {.lex_state = 15}, + [311] = {.lex_state = 13}, + [312] = {.lex_state = 13}, + [313] = {.lex_state = 15}, + [314] = {.lex_state = 15}, + [315] = {.lex_state = 13}, + [316] = {.lex_state = 13}, + [317] = {.lex_state = 13}, + [318] = {.lex_state = 13}, + [319] = {.lex_state = 13}, + [320] = {.lex_state = 3}, + [321] = {.lex_state = 15}, + [322] = {.lex_state = 13}, + [323] = {.lex_state = 13}, + [324] = {.lex_state = 13}, + [325] = {.lex_state = 13}, + [326] = {.lex_state = 13}, + [327] = {.lex_state = 13}, + [328] = {.lex_state = 13}, + [329] = {.lex_state = 13}, + [330] = {.lex_state = 13}, + [331] = {.lex_state = 13}, + [332] = {.lex_state = 13}, + [333] = {.lex_state = 13}, + [334] = {.lex_state = 3}, + [335] = {.lex_state = 3}, + [336] = {.lex_state = 3}, + [337] = {.lex_state = 3}, + [338] = {.lex_state = 13}, + [339] = {.lex_state = 13}, + [340] = {.lex_state = 13}, + [341] = {.lex_state = 15}, + [342] = {.lex_state = 13}, + [343] = {.lex_state = 3}, + [344] = {.lex_state = 3}, + [345] = {.lex_state = 3}, + [346] = {.lex_state = 15}, + [347] = {.lex_state = 13}, + [348] = {.lex_state = 15}, + [349] = {.lex_state = 15}, + [350] = {.lex_state = 15}, + [351] = {.lex_state = 3}, + [352] = {.lex_state = 15}, + [353] = {.lex_state = 13}, + [354] = {.lex_state = 15}, + [355] = {.lex_state = 15}, + [356] = {.lex_state = 15}, + [357] = {.lex_state = 13}, + [358] = {.lex_state = 13}, + [359] = {.lex_state = 13}, + [360] = {.lex_state = 13}, + [361] = {.lex_state = 3}, + [362] = {.lex_state = 3}, + [363] = {.lex_state = 15}, + [364] = {.lex_state = 13}, + [365] = {.lex_state = 15}, + [366] = {.lex_state = 15}, + [367] = {.lex_state = 13}, + [368] = {.lex_state = 13}, + [369] = {.lex_state = 13}, + [370] = {.lex_state = 13}, + [371] = {.lex_state = 13}, + [372] = {.lex_state = 13}, + [373] = {.lex_state = 15}, + [374] = {.lex_state = 15}, + [375] = {.lex_state = 15}, + [376] = {.lex_state = 13}, + [377] = {.lex_state = 3}, + [378] = {.lex_state = 13}, + [379] = {.lex_state = 15}, + [380] = {.lex_state = 13}, + [381] = {.lex_state = 15}, + [382] = {.lex_state = 15}, + [383] = {.lex_state = 15}, + [384] = {.lex_state = 13}, + [385] = {.lex_state = 13}, + [386] = {.lex_state = 13}, + [387] = {.lex_state = 15}, + [388] = {.lex_state = 13}, + [389] = {.lex_state = 15}, + [390] = {.lex_state = 15}, + [391] = {.lex_state = 3}, + [392] = {.lex_state = 13}, + [393] = {.lex_state = 15}, + [394] = {.lex_state = 3}, + [395] = {.lex_state = 15}, + [396] = {.lex_state = 13}, + [397] = {.lex_state = 15}, + [398] = {.lex_state = 3}, + [399] = {.lex_state = 13}, + [400] = {.lex_state = 13}, + [401] = {.lex_state = 13}, + [402] = {.lex_state = 13}, + [403] = {.lex_state = 3}, + [404] = {.lex_state = 3}, + [405] = {.lex_state = 15}, + [406] = {.lex_state = 13}, + [407] = {.lex_state = 15}, + [408] = {.lex_state = 15}, + [409] = {.lex_state = 15}, + [410] = {.lex_state = 15}, + [411] = {.lex_state = 13}, + [412] = {.lex_state = 13}, + [413] = {.lex_state = 15}, + [414] = {.lex_state = 13}, + [415] = {.lex_state = 15}, + [416] = {.lex_state = 13}, + [417] = {.lex_state = 15}, + [418] = {.lex_state = 15}, + [419] = {.lex_state = 3}, + [420] = {.lex_state = 13}, + [421] = {.lex_state = 13}, + [422] = {.lex_state = 13}, + [423] = {.lex_state = 15}, + [424] = {.lex_state = 13}, + [425] = {.lex_state = 15}, + [426] = {.lex_state = 15}, + [427] = {.lex_state = 13}, + [428] = {.lex_state = 13}, + [429] = {.lex_state = 13}, + [430] = {.lex_state = 15}, + [431] = {.lex_state = 13}, + [432] = {.lex_state = 13}, + [433] = {.lex_state = 13}, + [434] = {.lex_state = 13}, + [435] = {.lex_state = 13}, + [436] = {.lex_state = 13}, + [437] = {.lex_state = 13}, + [438] = {.lex_state = 15}, + [439] = {.lex_state = 13}, + [440] = {.lex_state = 13}, + [441] = {.lex_state = 13}, + [442] = {.lex_state = 13}, + [443] = {.lex_state = 13}, + [444] = {.lex_state = 13}, + [445] = {.lex_state = 13}, + [446] = {.lex_state = 13}, + [447] = {.lex_state = 13}, + [448] = {.lex_state = 13}, + [449] = {.lex_state = 13}, + [450] = {.lex_state = 13}, + [451] = {.lex_state = 13}, + [452] = {.lex_state = 13}, + [453] = {.lex_state = 13}, + [454] = {.lex_state = 13}, + [455] = {.lex_state = 13}, + [456] = {.lex_state = 13}, + [457] = {.lex_state = 13}, + [458] = {.lex_state = 13}, + [459] = {.lex_state = 13}, + [460] = {.lex_state = 13}, + [461] = {.lex_state = 13}, + [462] = {.lex_state = 13}, + [463] = {.lex_state = 13}, + [464] = {.lex_state = 13}, + [465] = {.lex_state = 14}, + [466] = {.lex_state = 3}, + [467] = {.lex_state = 3}, + [468] = {.lex_state = 3}, + [469] = {.lex_state = 15}, + [470] = {.lex_state = 14}, + [471] = {.lex_state = 3}, + [472] = {.lex_state = 3}, + [473] = {.lex_state = 3}, + [474] = {.lex_state = 3}, + [475] = {.lex_state = 15}, + [476] = {.lex_state = 13}, + [477] = {.lex_state = 13}, + [478] = {.lex_state = 3}, + [479] = {.lex_state = 13}, + [480] = {.lex_state = 15}, + [481] = {.lex_state = 3}, + [482] = {.lex_state = 13}, + [483] = {.lex_state = 13}, + [484] = {.lex_state = 13}, + [485] = {.lex_state = 13}, + [486] = {.lex_state = 15}, + [487] = {.lex_state = 13}, + [488] = {.lex_state = 15}, + [489] = {.lex_state = 15}, + [490] = {.lex_state = 13}, + [491] = {.lex_state = 13}, + [492] = {.lex_state = 13}, + [493] = {.lex_state = 15}, + [494] = {.lex_state = 13}, + [495] = {.lex_state = 13}, + [496] = {.lex_state = 13}, + [497] = {.lex_state = 13}, + [498] = {.lex_state = 13}, + [499] = {.lex_state = 13}, + [500] = {.lex_state = 13}, + [501] = {.lex_state = 13}, + [502] = {.lex_state = 15}, + [503] = {.lex_state = 13}, + [504] = {.lex_state = 13}, + [505] = {.lex_state = 13}, + [506] = {.lex_state = 13}, + [507] = {.lex_state = 3}, + [508] = {.lex_state = 13}, + [509] = {.lex_state = 13}, + [510] = {.lex_state = 15}, + [511] = {.lex_state = 13}, + [512] = {.lex_state = 15}, + [513] = {.lex_state = 15}, + [514] = {.lex_state = 13}, + [515] = {.lex_state = 13}, + [516] = {.lex_state = 15}, + [517] = {.lex_state = 15}, + [518] = {.lex_state = 3}, + [519] = {.lex_state = 15}, + [520] = {.lex_state = 15}, + [521] = {.lex_state = 15}, + [522] = {.lex_state = 13}, + [523] = {.lex_state = 3}, + [524] = {.lex_state = 13}, + [525] = {.lex_state = 13}, + [526] = {.lex_state = 15}, + [527] = {.lex_state = 13}, + [528] = {.lex_state = 13}, + [529] = {.lex_state = 15}, + [530] = {.lex_state = 13}, + [531] = {.lex_state = 13}, + [532] = {.lex_state = 13}, + [533] = {.lex_state = 13}, + [534] = {.lex_state = 13}, + [535] = {.lex_state = 3}, + [536] = {.lex_state = 15}, + [537] = {.lex_state = 15}, + [538] = {.lex_state = 13}, + [539] = {.lex_state = 13}, + [540] = {.lex_state = 15}, + [541] = {.lex_state = 13}, + [542] = {.lex_state = 13}, + [543] = {.lex_state = 15}, + [544] = {.lex_state = 13}, + [545] = {.lex_state = 15}, + [546] = {.lex_state = 13}, + [547] = {.lex_state = 13}, + [548] = {.lex_state = 3}, + [549] = {.lex_state = 15}, + [550] = {.lex_state = 13}, + [551] = {.lex_state = 13}, + [552] = {.lex_state = 3}, + [553] = {.lex_state = 15}, + [554] = {.lex_state = 15}, + [555] = {.lex_state = 15}, + [556] = {.lex_state = 15}, + [557] = {.lex_state = 15}, + [558] = {.lex_state = 13}, + [559] = {.lex_state = 15}, + [560] = {.lex_state = 13}, + [561] = {.lex_state = 15}, + [562] = {.lex_state = 13}, + [563] = {.lex_state = 13}, + [564] = {.lex_state = 13}, + [565] = {.lex_state = 13}, + [566] = {.lex_state = 3}, + [567] = {.lex_state = 15}, + [568] = {.lex_state = 15}, + [569] = {.lex_state = 15}, + [570] = {.lex_state = 15}, + [571] = {.lex_state = 13}, + [572] = {.lex_state = 13}, + [573] = {.lex_state = 13}, + [574] = {.lex_state = 13}, + [575] = {.lex_state = 13}, + [576] = {.lex_state = 13}, + [577] = {.lex_state = 13}, + [578] = {.lex_state = 13}, + [579] = {.lex_state = 13}, + [580] = {.lex_state = 13}, + [581] = {.lex_state = 13}, + [582] = {.lex_state = 13}, + [583] = {.lex_state = 13}, + [584] = {.lex_state = 13}, + [585] = {.lex_state = 3}, + [586] = {.lex_state = 15}, + [587] = {.lex_state = 13}, + [588] = {.lex_state = 15}, + [589] = {.lex_state = 15}, + [590] = {.lex_state = 15}, + [591] = {.lex_state = 13}, + [592] = {.lex_state = 15}, + [593] = {.lex_state = 13}, + [594] = {.lex_state = 13}, + [595] = {.lex_state = 15}, + [596] = {.lex_state = 13}, + [597] = {.lex_state = 3}, + [598] = {.lex_state = 3}, + [599] = {.lex_state = 15}, + [600] = {.lex_state = 13}, + [601] = {.lex_state = 15}, + [602] = {.lex_state = 13}, + [603] = {.lex_state = 13}, + [604] = {.lex_state = 15}, + [605] = {.lex_state = 3}, + [606] = {.lex_state = 13}, + [607] = {.lex_state = 13}, + [608] = {.lex_state = 13}, + [609] = {.lex_state = 13}, + [610] = {.lex_state = 13}, + [611] = {.lex_state = 13}, + [612] = {.lex_state = 13}, + [613] = {.lex_state = 13}, + [614] = {.lex_state = 13}, + [615] = {.lex_state = 13}, + [616] = {.lex_state = 13}, + [617] = {.lex_state = 13}, + [618] = {.lex_state = 13}, + [619] = {.lex_state = 13}, + [620] = {.lex_state = 13}, + [621] = {.lex_state = 13}, + [622] = {.lex_state = 15}, + [623] = {.lex_state = 13}, + [624] = {.lex_state = 13}, + [625] = {.lex_state = 15}, + [626] = {.lex_state = 15}, + [627] = {.lex_state = 15}, + [628] = {.lex_state = 13}, + [629] = {.lex_state = 3}, + [630] = {.lex_state = 13}, + [631] = {.lex_state = 13}, + [632] = {.lex_state = 13}, + [633] = {.lex_state = 13}, + [634] = {.lex_state = 13}, + [635] = {.lex_state = 13}, + [636] = {.lex_state = 13}, + [637] = {.lex_state = 13}, + [638] = {.lex_state = 13}, + [639] = {.lex_state = 13}, + [640] = {.lex_state = 3}, + [641] = {.lex_state = 13}, + [642] = {.lex_state = 3}, + [643] = {.lex_state = 13}, + [644] = {.lex_state = 15}, + [645] = {.lex_state = 13}, + [646] = {.lex_state = 13}, + [647] = {.lex_state = 13}, + [648] = {.lex_state = 3}, + [649] = {.lex_state = 13}, + [650] = {.lex_state = 13}, + [651] = {.lex_state = 13}, + [652] = {.lex_state = 3}, + [653] = {.lex_state = 13}, + [654] = {.lex_state = 15}, + [655] = {.lex_state = 13}, + [656] = {.lex_state = 3}, + [657] = {.lex_state = 15}, + [658] = {.lex_state = 13}, + [659] = {.lex_state = 15}, + [660] = {.lex_state = 13}, + [661] = {.lex_state = 13}, + [662] = {.lex_state = 15}, + [663] = {.lex_state = 3}, + [664] = {.lex_state = 3}, + [665] = {.lex_state = 3}, + [666] = {.lex_state = 3}, + [667] = {.lex_state = 3}, + [668] = {.lex_state = 3}, + [669] = {.lex_state = 3}, + [670] = {.lex_state = 3}, + [671] = {.lex_state = 3}, + [672] = {.lex_state = 3}, + [673] = {.lex_state = 3}, + [674] = {.lex_state = 3}, + [675] = {.lex_state = 3}, + [676] = {.lex_state = 3}, + [677] = {.lex_state = 3}, + [678] = {.lex_state = 3}, + [679] = {.lex_state = 3}, + [680] = {.lex_state = 3}, + [681] = {.lex_state = 3}, + [682] = {.lex_state = 3}, + [683] = {.lex_state = 3}, + [684] = {.lex_state = 3}, + [685] = {.lex_state = 3}, + [686] = {.lex_state = 3}, + [687] = {.lex_state = 3}, + [688] = {.lex_state = 3}, + [689] = {.lex_state = 3}, + [690] = {.lex_state = 3}, + [691] = {.lex_state = 3}, + [692] = {.lex_state = 3}, + [693] = {.lex_state = 3}, + [694] = {.lex_state = 3}, + [695] = {.lex_state = 3}, + [696] = {.lex_state = 3}, + [697] = {.lex_state = 3}, + [698] = {.lex_state = 3}, + [699] = {.lex_state = 3}, + [700] = {.lex_state = 3}, + [701] = {.lex_state = 3}, + [702] = {.lex_state = 3}, + [703] = {.lex_state = 3}, + [704] = {.lex_state = 3}, + [705] = {.lex_state = 3}, + [706] = {.lex_state = 3}, + [707] = {.lex_state = 3}, + [708] = {.lex_state = 3}, + [709] = {.lex_state = 3}, + [710] = {.lex_state = 3}, + [711] = {.lex_state = 3}, + [712] = {.lex_state = 16}, + [713] = {.lex_state = 16}, + [714] = {.lex_state = 16}, + [715] = {.lex_state = 16}, + [716] = {.lex_state = 16}, + [717] = {.lex_state = 16}, + [718] = {.lex_state = 16}, + [719] = {.lex_state = 16}, + [720] = {.lex_state = 16}, + [721] = {.lex_state = 16}, + [722] = {.lex_state = 16}, + [723] = {.lex_state = 16}, + [724] = {.lex_state = 0}, + [725] = {.lex_state = 3}, + [726] = {.lex_state = 3}, + [727] = {.lex_state = 0}, + [728] = {.lex_state = 1}, + [729] = {.lex_state = 0}, + [730] = {.lex_state = 0}, + [731] = {.lex_state = 1}, + [732] = {.lex_state = 0}, + [733] = {.lex_state = 0}, + [734] = {.lex_state = 0}, + [735] = {.lex_state = 0}, + [736] = {.lex_state = 14}, + [737] = {.lex_state = 0}, + [738] = {.lex_state = 0}, + [739] = {.lex_state = 13}, + [740] = {.lex_state = 0}, + [741] = {.lex_state = 14}, + [742] = {.lex_state = 0}, + [743] = {.lex_state = 14}, + [744] = {.lex_state = 13}, + [745] = {.lex_state = 0}, + [746] = {.lex_state = 14}, + [747] = {.lex_state = 0}, + [748] = {.lex_state = 15}, + [749] = {.lex_state = 0}, + [750] = {.lex_state = 0}, + [751] = {.lex_state = 0}, + [752] = {.lex_state = 0}, + [753] = {.lex_state = 0}, + [754] = {.lex_state = 0}, + [755] = {.lex_state = 18}, + [756] = {.lex_state = 0}, + [757] = {.lex_state = 0}, + [758] = {.lex_state = 0}, + [759] = {.lex_state = 18}, + [760] = {.lex_state = 16}, + [761] = {.lex_state = 15}, + [762] = {.lex_state = 17}, + [763] = {.lex_state = 15}, + [764] = {.lex_state = 15}, + [765] = {.lex_state = 21}, + [766] = {.lex_state = 13}, + [767] = {.lex_state = 13}, + [768] = {.lex_state = 0}, + [769] = {.lex_state = 13}, + [770] = {.lex_state = 17}, + [771] = {.lex_state = 0}, + [772] = {.lex_state = 0}, + [773] = {.lex_state = 20}, + [774] = {.lex_state = 0}, + [775] = {.lex_state = 0}, + [776] = {.lex_state = 0}, + [777] = {.lex_state = 0}, + [778] = {.lex_state = 20}, + [779] = {.lex_state = 0}, + [780] = {.lex_state = 0}, + [781] = {.lex_state = 14}, + [782] = {.lex_state = 16}, + [783] = {.lex_state = 0}, + [784] = {.lex_state = 0}, + [785] = {.lex_state = 0}, + [786] = {.lex_state = 14}, + [787] = {.lex_state = 14}, + [788] = {.lex_state = 14}, + [789] = {.lex_state = 14}, + [790] = {.lex_state = 0}, + [791] = {.lex_state = 0}, + [792] = {.lex_state = 0}, + [793] = {.lex_state = 14}, + [794] = {.lex_state = 15}, + [795] = {.lex_state = 15}, + [796] = {.lex_state = 15}, + [797] = {.lex_state = 13}, + [798] = {.lex_state = 15}, + [799] = {.lex_state = 15}, + [800] = {.lex_state = 0}, + [801] = {.lex_state = 14}, + [802] = {.lex_state = 14}, + [803] = {.lex_state = 14}, + [804] = {.lex_state = 14}, + [805] = {.lex_state = 0}, + [806] = {.lex_state = 14}, + [807] = {.lex_state = 14}, + [808] = {.lex_state = 14}, + [809] = {.lex_state = 14}, + [810] = {.lex_state = 3}, + [811] = {.lex_state = 19}, + [812] = {.lex_state = 15}, + [813] = {.lex_state = 14}, + [814] = {.lex_state = 14}, + [815] = {.lex_state = 14}, + [816] = {.lex_state = 14}, + [817] = {.lex_state = 0}, + [818] = {.lex_state = 14}, + [819] = {.lex_state = 14}, + [820] = {.lex_state = 14}, + [821] = {.lex_state = 14}, + [822] = {.lex_state = 14}, + [823] = {.lex_state = 14}, + [824] = {.lex_state = 14}, + [825] = {.lex_state = 14}, + [826] = {.lex_state = 14}, + [827] = {.lex_state = 14}, + [828] = {.lex_state = 14}, + [829] = {.lex_state = 14}, + [830] = {.lex_state = 14}, + [831] = {.lex_state = 13}, + [832] = {.lex_state = 35}, + [833] = {.lex_state = 13}, + [834] = {.lex_state = 13}, + [835] = {.lex_state = 13}, + [836] = {.lex_state = 13}, + [837] = {.lex_state = 13}, + [838] = {.lex_state = 0}, + [839] = {.lex_state = 3}, + [840] = {.lex_state = 29}, + [841] = {.lex_state = 19}, + [842] = {.lex_state = 13}, + [843] = {.lex_state = 14}, + [844] = {.lex_state = 13}, + [845] = {.lex_state = 15}, + [846] = {.lex_state = 15}, + [847] = {.lex_state = 15}, + [848] = {.lex_state = 15}, + [849] = {.lex_state = 15}, + [850] = {.lex_state = 15}, + [851] = {.lex_state = 15}, + [852] = {.lex_state = 15}, + [853] = {.lex_state = 15}, + [854] = {.lex_state = 15}, + [855] = {.lex_state = 15}, + [856] = {.lex_state = 15}, + [857] = {.lex_state = 15}, + [858] = {.lex_state = 15}, + [859] = {.lex_state = 15}, + [860] = {.lex_state = 15}, + [861] = {.lex_state = 15}, + [862] = {.lex_state = 15}, + [863] = {.lex_state = 13}, + [864] = {.lex_state = 14}, + [865] = {.lex_state = 14}, + [866] = {.lex_state = 14}, + [867] = {.lex_state = 14}, + [868] = {.lex_state = 14}, + [869] = {.lex_state = 14}, + [870] = {.lex_state = 14}, + [871] = {.lex_state = 14}, + [872] = {.lex_state = 14}, + [873] = {.lex_state = 14}, + [874] = {.lex_state = 13}, + [875] = {.lex_state = 28}, + [876] = {.lex_state = 13}, + [877] = {.lex_state = 14}, + [878] = {.lex_state = 14}, + [879] = {.lex_state = 14}, + [880] = {.lex_state = 14}, + [881] = {.lex_state = 14}, + [882] = {.lex_state = 15}, + [883] = {.lex_state = 14}, + [884] = {.lex_state = 15}, + [885] = {.lex_state = 15}, + [886] = {.lex_state = 15}, + [887] = {.lex_state = 14}, + [888] = {.lex_state = 14}, + [889] = {.lex_state = 14}, + [890] = {.lex_state = 14}, + [891] = {.lex_state = 14}, + [892] = {.lex_state = 14}, + [893] = {.lex_state = 13}, + [894] = {.lex_state = 14}, + [895] = {.lex_state = 14}, + [896] = {.lex_state = 14}, + [897] = {.lex_state = 14}, + [898] = {.lex_state = 14}, + [899] = {.lex_state = 14}, + [900] = {.lex_state = 14}, + [901] = {.lex_state = 14}, + [902] = {.lex_state = 14}, + [903] = {.lex_state = 14}, + [904] = {.lex_state = 14}, + [905] = {.lex_state = 14}, + [906] = {.lex_state = 14}, + [907] = {.lex_state = 14}, + [908] = {.lex_state = 14}, + [909] = {.lex_state = 14}, + [910] = {.lex_state = 14}, + [911] = {.lex_state = 14}, + [912] = {.lex_state = 14}, + [913] = {.lex_state = 14}, + [914] = {.lex_state = 13}, + [915] = {.lex_state = 14}, + [916] = {.lex_state = 14}, + [917] = {.lex_state = 14}, + [918] = {.lex_state = 14}, + [919] = {.lex_state = 14}, + [920] = {.lex_state = 14}, + [921] = {.lex_state = 14}, + [922] = {.lex_state = 14}, + [923] = {.lex_state = 14}, + [924] = {.lex_state = 14}, + [925] = {.lex_state = 14}, + [926] = {.lex_state = 14}, + [927] = {.lex_state = 14}, + [928] = {.lex_state = 14}, + [929] = {.lex_state = 14}, + [930] = {.lex_state = 14}, + [931] = {.lex_state = 13}, + [932] = {.lex_state = 14}, + [933] = {.lex_state = 14}, + [934] = {.lex_state = 14}, + [935] = {.lex_state = 14}, + [936] = {.lex_state = 14}, + [937] = {.lex_state = 14}, + [938] = {.lex_state = 14}, + [939] = {.lex_state = 14}, + [940] = {.lex_state = 14}, + [941] = {.lex_state = 14}, + [942] = {.lex_state = 14}, + [943] = {.lex_state = 14}, + [944] = {.lex_state = 14}, + [945] = {.lex_state = 14}, + [946] = {.lex_state = 14}, + [947] = {.lex_state = 14}, + [948] = {.lex_state = 13}, + [949] = {.lex_state = 28}, + [950] = {.lex_state = 13}, + [951] = {.lex_state = 13}, + [952] = {.lex_state = 13}, + [953] = {.lex_state = 0}, + [954] = {.lex_state = 0}, + [955] = {.lex_state = 15}, + [956] = {.lex_state = 30}, + [957] = {.lex_state = 0}, + [958] = {.lex_state = 0}, + [959] = {.lex_state = 0}, + [960] = {.lex_state = 0}, + [961] = {.lex_state = 0}, + [962] = {.lex_state = 34}, + [963] = {.lex_state = 15}, + [964] = {.lex_state = 13}, + [965] = {.lex_state = 13}, + [966] = {.lex_state = 0}, + [967] = {.lex_state = 15}, + [968] = {.lex_state = 13}, + [969] = {.lex_state = 13}, + [970] = {.lex_state = 0}, + [971] = {.lex_state = 15}, + [972] = {.lex_state = 3}, + [973] = {.lex_state = 28}, + [974] = {.lex_state = 13}, + [975] = {.lex_state = 3}, + [976] = {.lex_state = 0}, + [977] = {.lex_state = 0}, + [978] = {.lex_state = 0}, + [979] = {.lex_state = 13}, + [980] = {.lex_state = 13}, + [981] = {.lex_state = 0}, + [982] = {.lex_state = 0}, + [983] = {.lex_state = 13}, + [984] = {.lex_state = 13}, + [985] = {.lex_state = 3}, + [986] = {.lex_state = 0}, + [987] = {.lex_state = 0}, + [988] = {.lex_state = 0}, + [989] = {.lex_state = 0}, + [990] = {.lex_state = 0}, + [991] = {.lex_state = 13}, + [992] = {.lex_state = 13}, + [993] = {.lex_state = 13}, + [994] = {.lex_state = 13}, + [995] = {.lex_state = 0}, + [996] = {.lex_state = 0}, + [997] = {.lex_state = 26}, + [998] = {.lex_state = 0}, + [999] = {.lex_state = 0}, + [1000] = {.lex_state = 28}, + [1001] = {.lex_state = 0}, + [1002] = {.lex_state = 0}, + [1003] = {.lex_state = 13}, + [1004] = {.lex_state = 13}, + [1005] = {.lex_state = 13}, + [1006] = {.lex_state = 13}, + [1007] = {.lex_state = 13}, + [1008] = {.lex_state = 14}, + [1009] = {.lex_state = 13}, + [1010] = {.lex_state = 15}, + [1011] = {.lex_state = 15}, + [1012] = {.lex_state = 13}, + [1013] = {.lex_state = 13}, + [1014] = {.lex_state = 13}, + [1015] = {.lex_state = 13}, + [1016] = {.lex_state = 13}, + [1017] = {.lex_state = 13}, + [1018] = {.lex_state = 13}, + [1019] = {.lex_state = 15}, + [1020] = {.lex_state = 15}, + [1021] = {.lex_state = 13}, + [1022] = {.lex_state = 15}, + [1023] = {.lex_state = 15}, + [1024] = {.lex_state = 15}, + [1025] = {.lex_state = 15}, + [1026] = {.lex_state = 15}, + [1027] = {.lex_state = 13}, + [1028] = {.lex_state = 15}, + [1029] = {.lex_state = 15}, + [1030] = {.lex_state = 15}, + [1031] = {.lex_state = 15}, + [1032] = {.lex_state = 15}, + [1033] = {.lex_state = 13}, + [1034] = {.lex_state = 15}, + [1035] = {.lex_state = 13}, + [1036] = {.lex_state = 13}, + [1037] = {.lex_state = 15}, + [1038] = {.lex_state = 15}, + [1039] = {.lex_state = 13}, + [1040] = {.lex_state = 13}, + [1041] = {.lex_state = 13}, + [1042] = {.lex_state = 13}, + [1043] = {.lex_state = 15}, + [1044] = {.lex_state = 15}, + [1045] = {.lex_state = 15}, + [1046] = {.lex_state = 15}, + [1047] = {.lex_state = 15}, + [1048] = {.lex_state = 15}, + [1049] = {.lex_state = 15}, + [1050] = {.lex_state = 13}, + [1051] = {.lex_state = 13}, + [1052] = {.lex_state = 15}, + [1053] = {.lex_state = 15}, + [1054] = {.lex_state = 15}, + [1055] = {.lex_state = 15}, + [1056] = {.lex_state = 0}, + [1057] = {.lex_state = 13}, + [1058] = {.lex_state = 15}, + [1059] = {.lex_state = 15}, + [1060] = {.lex_state = 13}, + [1061] = {.lex_state = 15}, + [1062] = {.lex_state = 15}, + [1063] = {.lex_state = 15}, + [1064] = {.lex_state = 13}, + [1065] = {.lex_state = 15}, + [1066] = {.lex_state = 15}, + [1067] = {.lex_state = 13}, + [1068] = {.lex_state = 13}, + [1069] = {.lex_state = 13}, + [1070] = {.lex_state = 13}, + [1071] = {.lex_state = 13}, + [1072] = {.lex_state = 13}, + [1073] = {.lex_state = 13}, + [1074] = {.lex_state = 13}, + [1075] = {.lex_state = 13}, + [1076] = {.lex_state = 13}, + [1077] = {.lex_state = 13}, + [1078] = {.lex_state = 13}, + [1079] = {.lex_state = 15}, + [1080] = {.lex_state = 13}, + [1081] = {.lex_state = 13}, + [1082] = {.lex_state = 15}, + [1083] = {.lex_state = 13}, + [1084] = {.lex_state = 13}, + [1085] = {.lex_state = 13}, + [1086] = {.lex_state = 13}, + [1087] = {.lex_state = 15}, + [1088] = {.lex_state = 13}, + [1089] = {.lex_state = 13}, + [1090] = {.lex_state = 15}, + [1091] = {.lex_state = 27}, + [1092] = {.lex_state = 15}, + [1093] = {.lex_state = 33}, + [1094] = {.lex_state = 13}, + [1095] = {.lex_state = 13}, + [1096] = {.lex_state = 23}, + [1097] = {.lex_state = 13}, + [1098] = {.lex_state = 15}, + [1099] = {.lex_state = 15}, + [1100] = {.lex_state = 15}, + [1101] = {.lex_state = 13}, + [1102] = {.lex_state = 15}, + [1103] = {.lex_state = 15}, + [1104] = {.lex_state = 13}, + [1105] = {.lex_state = 15}, + [1106] = {.lex_state = 13}, + [1107] = {.lex_state = 13}, + [1108] = {.lex_state = 15}, + [1109] = {.lex_state = 13}, + [1110] = {.lex_state = 13}, + [1111] = {.lex_state = 13}, + [1112] = {.lex_state = 13}, + [1113] = {.lex_state = 15}, + [1114] = {.lex_state = 37}, + [1115] = {.lex_state = 15}, + [1116] = {.lex_state = 13}, + [1117] = {.lex_state = 15}, + [1118] = {.lex_state = 13}, + [1119] = {.lex_state = 15}, + [1120] = {.lex_state = 13}, + [1121] = {.lex_state = 15}, + [1122] = {.lex_state = 15}, + [1123] = {.lex_state = 13}, + [1124] = {.lex_state = 13}, + [1125] = {.lex_state = 13}, + [1126] = {.lex_state = 13}, + [1127] = {.lex_state = 13}, + [1128] = {.lex_state = 13}, + [1129] = {.lex_state = 13}, + [1130] = {.lex_state = 15}, + [1131] = {.lex_state = 13}, + [1132] = {.lex_state = 13}, + [1133] = {.lex_state = 0}, + [1134] = {.lex_state = 0}, + [1135] = {.lex_state = 27}, + [1136] = {.lex_state = 15}, + [1137] = {.lex_state = 13}, + [1138] = {.lex_state = 13}, + [1139] = {.lex_state = 13}, + [1140] = {.lex_state = 13}, + [1141] = {.lex_state = 13}, + [1142] = {.lex_state = 15}, + [1143] = {.lex_state = 13}, + [1144] = {.lex_state = 15}, + [1145] = {.lex_state = 15}, + [1146] = {.lex_state = 15}, + [1147] = {.lex_state = 13}, + [1148] = {.lex_state = 15}, + [1149] = {.lex_state = 15}, + [1150] = {.lex_state = 13}, + [1151] = {.lex_state = 15}, + [1152] = {.lex_state = 13}, + [1153] = {.lex_state = 15}, + [1154] = {.lex_state = 27}, + [1155] = {.lex_state = 13}, + [1156] = {.lex_state = 15}, + [1157] = {.lex_state = 13}, + [1158] = {.lex_state = 15}, + [1159] = {.lex_state = 13}, + [1160] = {.lex_state = 15}, + [1161] = {.lex_state = 13}, + [1162] = {.lex_state = 15}, + [1163] = {.lex_state = 13}, + [1164] = {.lex_state = 15}, + [1165] = {.lex_state = 15}, + [1166] = {.lex_state = 13}, + [1167] = {.lex_state = 15}, + [1168] = {.lex_state = 15}, + [1169] = {.lex_state = 15}, + [1170] = {.lex_state = 15}, + [1171] = {.lex_state = 15}, + [1172] = {.lex_state = 13}, + [1173] = {.lex_state = 13}, + [1174] = {.lex_state = 13}, + [1175] = {.lex_state = 27}, + [1176] = {.lex_state = 13}, + [1177] = {.lex_state = 24}, + [1178] = {.lex_state = 15}, + [1179] = {.lex_state = 13}, + [1180] = {.lex_state = 13}, + [1181] = {.lex_state = 13}, + [1182] = {.lex_state = 13}, + [1183] = {.lex_state = 13}, + [1184] = {.lex_state = 13}, + [1185] = {.lex_state = 13}, + [1186] = {.lex_state = 15}, + [1187] = {.lex_state = 13}, + [1188] = {.lex_state = 13}, + [1189] = {.lex_state = 15}, + [1190] = {.lex_state = 13}, + [1191] = {.lex_state = 13}, + [1192] = {.lex_state = 15}, + [1193] = {.lex_state = 13}, + [1194] = {.lex_state = 13}, + [1195] = {.lex_state = 15}, + [1196] = {.lex_state = 0}, + [1197] = {.lex_state = 32}, + [1198] = {.lex_state = 0}, + [1199] = {.lex_state = 32}, + [1200] = {.lex_state = 31}, + [1201] = {.lex_state = 32}, + [1202] = {.lex_state = 36}, + [1203] = {.lex_state = 0}, + [1204] = {.lex_state = 32}, + [1205] = {.lex_state = 0}, + [1206] = {.lex_state = 22}, + [1207] = {.lex_state = 25}, + [1208] = {.lex_state = 0}, + [1209] = {.lex_state = 13}, + [1210] = {.lex_state = 0}, + [1211] = {.lex_state = 3}, + [1212] = {.lex_state = 3}, + [1213] = {.lex_state = 13}, + [1214] = {.lex_state = 13}, + [1215] = {.lex_state = 3}, + [1216] = {.lex_state = 0}, + [1217] = {.lex_state = 3}, + [1218] = {.lex_state = 13}, + [1219] = {.lex_state = 0}, + [1220] = {.lex_state = 3}, + [1221] = {.lex_state = 0}, + [1222] = {.lex_state = 13}, + [1223] = {.lex_state = 0}, + [1224] = {.lex_state = 0}, + [1225] = {.lex_state = 3}, + [1226] = {.lex_state = 0}, + [1227] = {.lex_state = 3}, + [1228] = {.lex_state = 0}, + [1229] = {.lex_state = 0}, + [1230] = {.lex_state = 0}, + [1231] = {.lex_state = 0}, + [1232] = {.lex_state = 0}, + [1233] = {.lex_state = 0}, + [1234] = {.lex_state = 16}, + [1235] = {.lex_state = 13}, + [1236] = {.lex_state = 3}, + [1237] = {.lex_state = 0}, + [1238] = {.lex_state = 13}, + [1239] = {.lex_state = 16}, + [1240] = {.lex_state = 0}, + [1241] = {.lex_state = 13}, + [1242] = {.lex_state = 3}, + [1243] = {.lex_state = 16}, + [1244] = {.lex_state = 3}, + [1245] = {.lex_state = 0}, + [1246] = {.lex_state = 13}, + [1247] = {.lex_state = 0}, + [1248] = {.lex_state = 3}, + [1249] = {.lex_state = 0}, + [1250] = {.lex_state = 0}, + [1251] = {.lex_state = 13}, + [1252] = {.lex_state = 38}, + [1253] = {.lex_state = 0}, + [1254] = {.lex_state = 3}, + [1255] = {.lex_state = 38}, + [1256] = {.lex_state = 0}, + [1257] = {.lex_state = 0}, + [1258] = {.lex_state = 0}, + [1259] = {.lex_state = 0}, + [1260] = {.lex_state = 0}, + [1261] = {.lex_state = 0}, + [1262] = {.lex_state = 16}, + [1263] = {.lex_state = 0}, + [1264] = {.lex_state = 0}, + [1265] = {.lex_state = 0}, + [1266] = {.lex_state = 0}, + [1267] = {.lex_state = 0}, + [1268] = {.lex_state = 0}, + [1269] = {.lex_state = 0}, + [1270] = {.lex_state = 0}, + [1271] = {.lex_state = 0}, + [1272] = {.lex_state = 0}, + [1273] = {.lex_state = 0}, + [1274] = {.lex_state = 0}, + [1275] = {.lex_state = 0}, + [1276] = {.lex_state = 0}, + [1277] = {.lex_state = 0}, + [1278] = {.lex_state = 0}, + [1279] = {.lex_state = 0}, + [1280] = {.lex_state = 0}, + [1281] = {.lex_state = 0}, + [1282] = {.lex_state = 0}, + [1283] = {.lex_state = 0}, + [1284] = {.lex_state = 3}, + [1285] = {.lex_state = 0}, + [1286] = {.lex_state = 3}, + [1287] = {.lex_state = 0}, + [1288] = {.lex_state = 0}, + [1289] = {.lex_state = 0}, + [1290] = {.lex_state = 0}, + [1291] = {.lex_state = 0}, + [1292] = {.lex_state = 0}, + [1293] = {.lex_state = 0}, + [1294] = {.lex_state = 0}, + [1295] = {.lex_state = 0}, + [1296] = {.lex_state = 0}, + [1297] = {.lex_state = 0}, + [1298] = {.lex_state = 0}, + [1299] = {.lex_state = 0}, + [1300] = {.lex_state = 0}, + [1301] = {.lex_state = 0}, + [1302] = {.lex_state = 0}, + [1303] = {.lex_state = 0}, + [1304] = {.lex_state = 0}, + [1305] = {.lex_state = 0}, + [1306] = {.lex_state = 0}, + [1307] = {.lex_state = 0}, + [1308] = {.lex_state = 0}, + [1309] = {.lex_state = 0}, + [1310] = {.lex_state = 0}, + [1311] = {.lex_state = 13}, + [1312] = {.lex_state = 0}, + [1313] = {.lex_state = 13}, + [1314] = {.lex_state = 0}, + [1315] = {.lex_state = 0}, + [1316] = {.lex_state = 0}, + [1317] = {.lex_state = 0}, + [1318] = {.lex_state = 0}, + [1319] = {.lex_state = 0}, + [1320] = {.lex_state = 0}, + [1321] = {.lex_state = 13}, + [1322] = {.lex_state = 13}, + [1323] = {.lex_state = 0}, + [1324] = {.lex_state = 0}, + [1325] = {.lex_state = 0}, + [1326] = {.lex_state = 0}, + [1327] = {.lex_state = 0}, + [1328] = {.lex_state = 0}, + [1329] = {.lex_state = 0}, + [1330] = {.lex_state = 0}, + [1331] = {.lex_state = 0}, + [1332] = {.lex_state = 0}, + [1333] = {.lex_state = 0}, + [1334] = {.lex_state = 0}, + [1335] = {.lex_state = 0}, + [1336] = {.lex_state = 0}, + [1337] = {.lex_state = 13}, + [1338] = {.lex_state = 0}, + [1339] = {.lex_state = 38}, + [1340] = {.lex_state = 0}, + [1341] = {.lex_state = 0}, + [1342] = {.lex_state = 0}, + [1343] = {.lex_state = 0}, + [1344] = {.lex_state = 0}, + [1345] = {.lex_state = 13}, + [1346] = {.lex_state = 0}, + [1347] = {.lex_state = 0}, + [1348] = {.lex_state = 0}, + [1349] = {.lex_state = 0}, + [1350] = {.lex_state = 0}, + [1351] = {.lex_state = 0}, + [1352] = {.lex_state = 0}, + [1353] = {.lex_state = 0}, + [1354] = {.lex_state = 0}, + [1355] = {.lex_state = 0}, + [1356] = {.lex_state = 0}, + [1357] = {.lex_state = 0}, + [1358] = {.lex_state = 0}, + [1359] = {.lex_state = 0}, + [1360] = {.lex_state = 0}, + [1361] = {.lex_state = 0}, + [1362] = {.lex_state = 0}, + [1363] = {.lex_state = 0}, + [1364] = {.lex_state = 0}, + [1365] = {.lex_state = 0}, + [1366] = {.lex_state = 0}, + [1367] = {.lex_state = 0}, + [1368] = {.lex_state = 0}, + [1369] = {.lex_state = 0}, + [1370] = {.lex_state = 13}, + [1371] = {.lex_state = 0}, + [1372] = {.lex_state = 0}, + [1373] = {.lex_state = 0}, + [1374] = {.lex_state = 0}, + [1375] = {.lex_state = 0}, + [1376] = {.lex_state = 0}, + [1377] = {.lex_state = 13}, + [1378] = {.lex_state = 13}, + [1379] = {.lex_state = 0}, + [1380] = {.lex_state = 0}, + [1381] = {.lex_state = 13}, + [1382] = {.lex_state = 0}, + [1383] = {.lex_state = 0}, + [1384] = {.lex_state = 0}, + [1385] = {.lex_state = 13}, + [1386] = {.lex_state = 0}, + [1387] = {.lex_state = 0}, + [1388] = {.lex_state = 0}, + [1389] = {.lex_state = 0}, + [1390] = {.lex_state = 13}, + [1391] = {.lex_state = 0}, + [1392] = {.lex_state = 0}, + [1393] = {.lex_state = 0}, + [1394] = {.lex_state = 0}, + [1395] = {.lex_state = 0}, + [1396] = {.lex_state = 0}, + [1397] = {.lex_state = 0}, + [1398] = {.lex_state = 13}, + [1399] = {.lex_state = 0}, + [1400] = {.lex_state = 0}, + [1401] = {.lex_state = 0}, + [1402] = {.lex_state = 0}, + [1403] = {.lex_state = 0}, + [1404] = {.lex_state = 0}, + [1405] = {.lex_state = 13}, + [1406] = {.lex_state = 0}, + [1407] = {.lex_state = 0}, + [1408] = {.lex_state = 0}, + [1409] = {.lex_state = 13}, + [1410] = {.lex_state = 13}, + [1411] = {.lex_state = 13}, + [1412] = {.lex_state = 13}, + [1413] = {.lex_state = 0}, + [1414] = {.lex_state = 0}, + [1415] = {.lex_state = 0}, + [1416] = {.lex_state = 0}, + [1417] = {.lex_state = 0}, + [1418] = {.lex_state = 0}, + [1419] = {.lex_state = 0}, + [1420] = {.lex_state = 0}, + [1421] = {.lex_state = 0}, + [1422] = {.lex_state = 0}, + [1423] = {.lex_state = 0}, + [1424] = {.lex_state = 0}, + [1425] = {.lex_state = 0}, + [1426] = {.lex_state = 0}, + [1427] = {.lex_state = 0}, + [1428] = {.lex_state = 0}, + [1429] = {.lex_state = 0}, + [1430] = {.lex_state = 0}, + [1431] = {.lex_state = 0}, + [1432] = {.lex_state = 0}, + [1433] = {.lex_state = 0}, + [1434] = {.lex_state = 0}, + [1435] = {.lex_state = 0}, + [1436] = {.lex_state = 0}, + [1437] = {.lex_state = 0}, + [1438] = {.lex_state = 38}, + [1439] = {.lex_state = 0}, + [1440] = {.lex_state = 0, .external_lex_state = 1}, + [1441] = {.lex_state = 0}, + [1442] = {.lex_state = 0}, + [1443] = {.lex_state = 0}, + [1444] = {.lex_state = 0}, + [1445] = {.lex_state = 0}, + [1446] = {.lex_state = 0}, + [1447] = {.lex_state = 0}, + [1448] = {.lex_state = 0}, + [1449] = {.lex_state = 0}, + [1450] = {.lex_state = 0}, + [1451] = {.lex_state = 0}, + [1452] = {.lex_state = 0}, + [1453] = {.lex_state = 0}, + [1454] = {.lex_state = 0}, + [1455] = {.lex_state = 0}, + [1456] = {.lex_state = 0}, + [1457] = {.lex_state = 0}, + [1458] = {.lex_state = 0}, + [1459] = {.lex_state = 0}, + [1460] = {.lex_state = 0}, + [1461] = {.lex_state = 0}, + [1462] = {.lex_state = 0}, + [1463] = {.lex_state = 0}, + [1464] = {.lex_state = 0}, + [1465] = {.lex_state = 0}, + [1466] = {.lex_state = 0}, + [1467] = {.lex_state = 0}, + [1468] = {.lex_state = 0}, + [1469] = {.lex_state = 0}, + [1470] = {.lex_state = 0}, + [1471] = {.lex_state = 0}, + [1472] = {.lex_state = 0}, + [1473] = {.lex_state = 0}, + [1474] = {.lex_state = 0}, + [1475] = {.lex_state = 0}, + [1476] = {.lex_state = 0}, + [1477] = {.lex_state = 0}, + [1478] = {.lex_state = 0}, + [1479] = {.lex_state = 0}, + [1480] = {.lex_state = 0}, + [1481] = {.lex_state = 0}, + [1482] = {.lex_state = 0}, + [1483] = {.lex_state = 0}, + [1484] = {.lex_state = 0}, + [1485] = {.lex_state = 0}, + [1486] = {.lex_state = 0}, + [1487] = {.lex_state = 0}, + [1488] = {.lex_state = 0}, + [1489] = {.lex_state = 0}, + [1490] = {.lex_state = 0}, + [1491] = {.lex_state = 0}, + [1492] = {.lex_state = 0}, + [1493] = {.lex_state = 0}, + [1494] = {.lex_state = 0}, + [1495] = {.lex_state = 0}, + [1496] = {.lex_state = 0}, + [1497] = {.lex_state = 0}, + [1498] = {.lex_state = 0}, + [1499] = {.lex_state = 0}, + [1500] = {.lex_state = 0}, + [1501] = {.lex_state = 0}, + [1502] = {.lex_state = 0}, + [1503] = {.lex_state = 0}, + [1504] = {.lex_state = 0}, + [1505] = {.lex_state = 13}, + [1506] = {.lex_state = 0}, + [1507] = {.lex_state = 0}, + [1508] = {.lex_state = 0}, + [1509] = {.lex_state = 0}, + [1510] = {.lex_state = 0}, + [1511] = {.lex_state = 0}, + [1512] = {.lex_state = 0}, + [1513] = {.lex_state = 0}, + [1514] = {.lex_state = 0}, + [1515] = {.lex_state = 0}, + [1516] = {.lex_state = 0}, + [1517] = {.lex_state = 0}, + [1518] = {.lex_state = 0}, + [1519] = {.lex_state = 0}, + [1520] = {.lex_state = 0}, + [1521] = {.lex_state = 0}, + [1522] = {.lex_state = 0}, + [1523] = {.lex_state = 0}, + [1524] = {.lex_state = 0}, + [1525] = {.lex_state = 0}, + [1526] = {.lex_state = 0}, + [1527] = {.lex_state = 0}, + [1528] = {.lex_state = 0}, + [1529] = {.lex_state = 0}, + [1530] = {.lex_state = 0}, + [1531] = {.lex_state = 0}, + [1532] = {.lex_state = 0}, + [1533] = {.lex_state = 0}, + [1534] = {.lex_state = 0}, + [1535] = {.lex_state = 0}, + [1536] = {.lex_state = 0}, + [1537] = {.lex_state = 0}, + [1538] = {.lex_state = 0}, + [1539] = {.lex_state = 0}, + [1540] = {.lex_state = 13}, + [1541] = {.lex_state = 0}, + [1542] = {.lex_state = 0}, + [1543] = {.lex_state = 0}, + [1544] = {.lex_state = 0}, + [1545] = {.lex_state = 0}, + [1546] = {.lex_state = 0}, + [1547] = {.lex_state = 0}, + [1548] = {.lex_state = 0}, + [1549] = {.lex_state = 0}, + [1550] = {.lex_state = 0}, + [1551] = {.lex_state = 0}, + [1552] = {.lex_state = 0}, + [1553] = {.lex_state = 0}, + [1554] = {.lex_state = 0}, + [1555] = {.lex_state = 0}, + [1556] = {.lex_state = 0}, + [1557] = {.lex_state = 0}, + [1558] = {.lex_state = 0}, + [1559] = {.lex_state = 0}, + [1560] = {.lex_state = 0}, + [1561] = {.lex_state = 0}, + [1562] = {.lex_state = 0}, + [1563] = {.lex_state = 0}, + [1564] = {.lex_state = 0}, + [1565] = {.lex_state = 0}, + [1566] = {.lex_state = 0}, + [1567] = {.lex_state = 0}, + [1568] = {.lex_state = 0}, + [1569] = {.lex_state = 0}, + [1570] = {.lex_state = 0}, + [1571] = {.lex_state = 0}, + [1572] = {.lex_state = 0}, + [1573] = {.lex_state = 0}, + [1574] = {.lex_state = 0}, + [1575] = {.lex_state = 0}, + [1576] = {.lex_state = 0}, + [1577] = {.lex_state = 0}, + [1578] = {.lex_state = 0}, + [1579] = {.lex_state = 13}, + [1580] = {.lex_state = 0}, + [1581] = {.lex_state = 0}, + [1582] = {.lex_state = 0}, + [1583] = {.lex_state = 0}, + [1584] = {.lex_state = 0}, + [1585] = {.lex_state = 0}, + [1586] = {.lex_state = 0}, + [1587] = {.lex_state = 0}, + [1588] = {.lex_state = 0}, + [1589] = {.lex_state = 0}, + [1590] = {.lex_state = 0}, + [1591] = {.lex_state = 0}, + [1592] = {.lex_state = 0}, + [1593] = {.lex_state = 0}, + [1594] = {.lex_state = 0}, + [1595] = {.lex_state = 0}, + [1596] = {.lex_state = 0}, + [1597] = {.lex_state = 0}, + [1598] = {.lex_state = 0}, + [1599] = {.lex_state = 0}, + [1600] = {.lex_state = 0}, + [1601] = {.lex_state = 0}, + [1602] = {.lex_state = 0}, + [1603] = {.lex_state = 0}, + [1604] = {.lex_state = 0}, + [1605] = {.lex_state = 0}, + [1606] = {.lex_state = 0}, + [1607] = {.lex_state = 0}, + [1608] = {.lex_state = 0}, + [1609] = {.lex_state = 0}, + [1610] = {.lex_state = 0}, + [1611] = {.lex_state = 0}, + [1612] = {.lex_state = 0}, + [1613] = {.lex_state = 0}, + [1614] = {.lex_state = 0}, + [1615] = {.lex_state = 13}, + [1616] = {.lex_state = 0}, + [1617] = {.lex_state = 0}, + [1618] = {.lex_state = 0}, + [1619] = {.lex_state = 0}, + [1620] = {.lex_state = 0}, + [1621] = {.lex_state = 0}, + [1622] = {.lex_state = 0}, + [1623] = {.lex_state = 0}, + [1624] = {.lex_state = 0}, + [1625] = {.lex_state = 0}, + [1626] = {.lex_state = 0}, + [1627] = {.lex_state = 0}, + [1628] = {.lex_state = 0}, + [1629] = {.lex_state = 0}, + [1630] = {.lex_state = 0}, + [1631] = {.lex_state = 0}, + [1632] = {.lex_state = 0}, + [1633] = {.lex_state = 0}, + [1634] = {.lex_state = 0}, + [1635] = {.lex_state = 0}, + [1636] = {(TSStateId)(-1),}, + [1637] = {(TSStateId)(-1),}, + [1638] = {(TSStateId)(-1),}, + [1639] = {(TSStateId)(-1),}, + [1640] = {(TSStateId)(-1),}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [STATE(0)] = { + [sym__annotation] = STATE(0), + [sym_block_comment] = STATE(0), + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_i32] = ACTIONS(1), + [anon_sym_i64] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_array] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_block] = ACTIONS(1), + [anon_sym_end] = ACTIONS(1), + [anon_sym_if] = ACTIONS(1), + [anon_sym_else] = ACTIONS(1), + [anon_sym_then] = ACTIONS(1), + [anon_sym_loop] = ACTIONS(1), + [anon_sym_try_table] = ACTIONS(1), + [anon_sym_call_indirect] = ACTIONS(1), + [anon_sym_return_call_indirect] = ACTIONS(1), + [anon_sym_catch] = ACTIONS(1), + [anon_sym_catch_ref] = ACTIONS(1), + [anon_sym_catch_all] = ACTIONS(1), + [anon_sym_catch_all_ref] = ACTIONS(1), + [anon_sym_cont] = ACTIONS(1), + [anon_sym_data] = ACTIONS(1), + [anon_sym_elem] = ACTIONS(1), + [anon_sym_item] = ACTIONS(1), + [anon_sym_func] = ACTIONS(1), + [anon_sym_export] = ACTIONS(1), + [anon_sym_global] = ACTIONS(1), + [anon_sym_table] = ACTIONS(1), + [anon_sym_memory] = ACTIONS(1), + [anon_sym_tag] = ACTIONS(1), + [anon_sym_field] = ACTIONS(1), + [anon_sym_mut] = ACTIONS(1), + [anon_sym_any] = ACTIONS(1), + [anon_sym_eq] = ACTIONS(1), + [anon_sym_i31] = ACTIONS(1), + [anon_sym_struct] = ACTIONS(1), + [anon_sym_none] = ACTIONS(1), + [anon_sym_nofunc] = ACTIONS(1), + [anon_sym_exn] = ACTIONS(1), + [anon_sym_noexn] = ACTIONS(1), + [anon_sym_extern] = ACTIONS(1), + [anon_sym_noextern] = ACTIONS(1), + [anon_sym_nocont] = ACTIONS(1), + [anon_sym_import] = ACTIONS(1), + [anon_sym_local] = ACTIONS(1), + [anon_sym_pagesize] = ACTIONS(1), + [anon_sym_module] = ACTIONS(1), + [anon_sym_declare] = ACTIONS(1), + [anon_sym_start] = ACTIONS(1), + [anon_sym_f32] = ACTIONS(1), + [anon_sym_f64] = ACTIONS(1), + [anon_sym_offset] = ACTIONS(1), + [anon_sym_on] = ACTIONS(1), + [anon_sym_switch] = ACTIONS(1), + [anon_sym_i8] = ACTIONS(1), + [anon_sym_i16] = ACTIONS(1), + [anon_sym_param] = ACTIONS(1), + [anon_sym_rec] = ACTIONS(1), + [anon_sym_anyref] = ACTIONS(1), + [anon_sym_eqref] = ACTIONS(1), + [anon_sym_i31ref] = ACTIONS(1), + [anon_sym_structref] = ACTIONS(1), + [anon_sym_arrayref] = ACTIONS(1), + [anon_sym_nullref] = ACTIONS(1), + [anon_sym_funcref] = ACTIONS(1), + [anon_sym_exnref] = ACTIONS(1), + [anon_sym_externref] = ACTIONS(1), + [anon_sym_contref] = ACTIONS(1), + [anon_sym_ref] = ACTIONS(1), + [anon_sym_null] = ACTIONS(1), + [anon_sym_result] = ACTIONS(1), + [anon_sym_sub] = ACTIONS(1), + [anon_sym_final] = ACTIONS(1), + [anon_sym_type] = ACTIONS(1), + [sym_vec_type] = ACTIONS(1), + [sym_identifier] = ACTIONS(1), + [sym_integer] = ACTIONS(1), + [aux_sym_float_token1] = ACTIONS(1), + [aux_sym_float_token2] = ACTIONS(1), + [sym_mem_arg] = ACTIONS(1), + [anon_sym_i8x16] = ACTIONS(1), + [anon_sym_i16x8] = ACTIONS(1), + [anon_sym_shared] = ACTIONS(1), + [anon_sym_unshared] = ACTIONS(1), + [sym_string] = ACTIONS(1), + [sym_uinteger] = ACTIONS(1), + [sym_annotation_start] = ACTIONS(3), + [anon_sym_LPAREN_SEMI] = ACTIONS(5), + [anon_sym_SEMI_RPAREN] = ACTIONS(1), + [sym_line_comment] = ACTIONS(7), + [sym__block_comment_content] = ACTIONS(1), + }, + [STATE(1)] = { + [sym_root] = STATE(1479), + [sym_module] = STATE(1428), + [sym__module_field] = STATE(1384), + [sym_module_field_data] = STATE(1352), + [sym_module_field_elem] = STATE(1352), + [sym_module_field_export] = STATE(1352), + [sym_module_field_func] = STATE(1352), + [sym_module_field_global] = STATE(1352), + [sym_module_field_import] = STATE(1352), + [sym_module_field_memory] = STATE(1352), + [sym_module_field_start] = STATE(1352), + [sym_module_field_table] = STATE(1352), + [sym_module_field_tag] = STATE(1352), + [sym_rec_type] = STATE(1352), + [sym_type_def] = STATE(1352), + [sym__annotation] = STATE(1), + [sym_block_comment] = STATE(1), + [aux_sym_root_repeat1] = STATE(1265), + [aux_sym_root_repeat2] = STATE(730), + [ts_builtin_sym_end] = ACTIONS(9), + [anon_sym_LPAREN] = ACTIONS(11), + [sym_annotation_start] = ACTIONS(3), + [anon_sym_LPAREN_SEMI] = ACTIONS(5), + [sym_line_comment] = ACTIONS(7), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(17), 1, + anon_sym_RPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + STATE(4), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(1002), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(2), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [117] = 19, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(35), 1, + anon_sym_LPAREN, + ACTIONS(44), 1, + sym_identifier, + ACTIONS(46), 1, + sym_integer, + ACTIONS(48), 1, + aux_sym_float_token1, + ACTIONS(50), 1, + aux_sym_float_token2, + ACTIONS(56), 1, + sym_uinteger, + STATE(9), 1, + aux_sym_plain_instr_repeat1, + STATE(20), 1, + sym_index, + STATE(22), 1, + sym__immediate, + ACTIONS(52), 2, + sym_mem_arg, + sym_string, + STATE(3), 2, + sym__annotation, + sym_block_comment, + STATE(30), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(54), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(40), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(38), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(42), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [220] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(58), 1, + anon_sym_RPAREN, + STATE(19), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(959), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(4), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [337] = 19, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(44), 1, + sym_identifier, + ACTIONS(46), 1, + sym_integer, + ACTIONS(48), 1, + aux_sym_float_token1, + ACTIONS(50), 1, + aux_sym_float_token2, + ACTIONS(56), 1, + sym_uinteger, + ACTIONS(60), 1, + anon_sym_LPAREN, + STATE(3), 1, + aux_sym_plain_instr_repeat1, + STATE(20), 1, + sym_index, + STATE(22), 1, + sym__immediate, + ACTIONS(52), 2, + sym_mem_arg, + sym_string, + STATE(5), 2, + sym__annotation, + sym_block_comment, + STATE(30), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(54), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(63), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(38), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(42), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [440] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(65), 1, + anon_sym_RPAREN, + STATE(10), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(977), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(6), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [557] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(67), 1, + anon_sym_RPAREN, + STATE(8), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(954), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(7), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [674] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(69), 1, + anon_sym_RPAREN, + STATE(19), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(961), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(8), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [791] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(71), 1, + anon_sym_LPAREN, + ACTIONS(82), 1, + sym_identifier, + ACTIONS(85), 1, + sym_integer, + ACTIONS(88), 1, + aux_sym_float_token1, + ACTIONS(91), 1, + aux_sym_float_token2, + ACTIONS(100), 1, + sym_uinteger, + STATE(20), 1, + sym_index, + STATE(22), 1, + sym__immediate, + ACTIONS(94), 2, + sym_mem_arg, + sym_string, + STATE(9), 3, + sym__annotation, + sym_block_comment, + aux_sym_plain_instr_repeat1, + STATE(30), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(97), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(77), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(74), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(79), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [892] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(103), 1, + anon_sym_RPAREN, + STATE(19), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(982), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(10), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1009] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(105), 1, + anon_sym_RPAREN, + STATE(12), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(990), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(11), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1126] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(25), 1, + sym_integer, + ACTIONS(33), 1, + sym_uinteger, + ACTIONS(107), 1, + anon_sym_RPAREN, + STATE(19), 1, + aux_sym_plain_instr_repeat1, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(996), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + ACTIONS(27), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(29), 2, + sym_mem_arg, + sym_string, + STATE(12), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(19), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(31), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(15), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(21), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1243] = 19, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(109), 1, + anon_sym_LPAREN, + ACTIONS(116), 1, + sym_identifier, + ACTIONS(118), 1, + sym_integer, + ACTIONS(120), 1, + aux_sym_float_token1, + ACTIONS(122), 1, + aux_sym_float_token2, + ACTIONS(128), 1, + sym_uinteger, + STATE(16), 1, + aux_sym_plain_instr_repeat1, + STATE(34), 1, + sym_index, + STATE(38), 1, + sym__immediate, + ACTIONS(124), 2, + sym_mem_arg, + sym_string, + STATE(13), 2, + sym__annotation, + sym_block_comment, + STATE(36), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(126), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(63), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(112), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(114), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1345] = 19, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(130), 1, + anon_sym_LPAREN, + ACTIONS(136), 1, + anon_sym_RPAREN, + ACTIONS(141), 1, + sym_identifier, + ACTIONS(144), 1, + sym_integer, + ACTIONS(147), 1, + aux_sym_float_token1, + ACTIONS(150), 1, + aux_sym_float_token2, + ACTIONS(159), 1, + sym_uinteger, + STATE(44), 1, + sym__immediate, + STATE(51), 1, + sym_index, + ACTIONS(153), 2, + sym_mem_arg, + sym_string, + STATE(14), 3, + sym__annotation, + sym_block_comment, + aux_sym_plain_instr_repeat1, + STATE(39), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(156), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(77), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(133), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(138), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1447] = 20, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(162), 1, + anon_sym_LPAREN, + ACTIONS(167), 1, + anon_sym_RPAREN, + ACTIONS(171), 1, + sym_identifier, + ACTIONS(173), 1, + sym_integer, + ACTIONS(175), 1, + aux_sym_float_token1, + ACTIONS(177), 1, + aux_sym_float_token2, + ACTIONS(183), 1, + sym_uinteger, + STATE(14), 1, + aux_sym_plain_instr_repeat1, + STATE(44), 1, + sym__immediate, + STATE(51), 1, + sym_index, + ACTIONS(179), 2, + sym_mem_arg, + sym_string, + STATE(15), 2, + sym__annotation, + sym_block_comment, + STATE(39), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(181), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(40), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(165), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(169), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1551] = 19, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(116), 1, + sym_identifier, + ACTIONS(118), 1, + sym_integer, + ACTIONS(120), 1, + aux_sym_float_token1, + ACTIONS(122), 1, + aux_sym_float_token2, + ACTIONS(128), 1, + sym_uinteger, + ACTIONS(185), 1, + anon_sym_LPAREN, + STATE(17), 1, + aux_sym_plain_instr_repeat1, + STATE(34), 1, + sym_index, + STATE(38), 1, + sym__immediate, + ACTIONS(124), 2, + sym_mem_arg, + sym_string, + STATE(16), 2, + sym__annotation, + sym_block_comment, + STATE(36), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(126), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(40), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(112), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(114), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1653] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(188), 1, + anon_sym_LPAREN, + ACTIONS(197), 1, + sym_identifier, + ACTIONS(200), 1, + sym_integer, + ACTIONS(203), 1, + aux_sym_float_token1, + ACTIONS(206), 1, + aux_sym_float_token2, + ACTIONS(215), 1, + sym_uinteger, + STATE(34), 1, + sym_index, + STATE(38), 1, + sym__immediate, + ACTIONS(209), 2, + sym_mem_arg, + sym_string, + STATE(17), 3, + sym__annotation, + sym_block_comment, + aux_sym_plain_instr_repeat1, + STATE(36), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(212), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(77), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(191), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(194), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1753] = 20, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(171), 1, + sym_identifier, + ACTIONS(173), 1, + sym_integer, + ACTIONS(175), 1, + aux_sym_float_token1, + ACTIONS(177), 1, + aux_sym_float_token2, + ACTIONS(183), 1, + sym_uinteger, + ACTIONS(218), 1, + anon_sym_LPAREN, + ACTIONS(221), 1, + anon_sym_RPAREN, + STATE(15), 1, + aux_sym_plain_instr_repeat1, + STATE(44), 1, + sym__immediate, + STATE(51), 1, + sym_index, + ACTIONS(179), 2, + sym_mem_arg, + sym_string, + STATE(18), 2, + sym__annotation, + sym_block_comment, + STATE(39), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(181), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(63), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + ACTIONS(165), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + ACTIONS(169), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1857] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(136), 1, + anon_sym_RPAREN, + ACTIONS(223), 1, + anon_sym_LPAREN, + ACTIONS(235), 1, + sym_identifier, + ACTIONS(238), 1, + sym_integer, + ACTIONS(250), 1, + sym_uinteger, + STATE(53), 1, + sym__immediate, + STATE(61), 1, + sym_index, + ACTIONS(241), 2, + aux_sym_float_token1, + aux_sym_float_token2, + ACTIONS(244), 2, + sym_mem_arg, + sym_string, + STATE(19), 3, + sym__annotation, + sym_block_comment, + aux_sym_plain_instr_repeat1, + ACTIONS(229), 5, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + STATE(57), 5, + sym_heap_type, + sym_on_clause, + sym_ref_type, + sym_float, + sym_shape_descriptor, + ACTIONS(247), 6, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + ACTIONS(226), 9, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + ACTIONS(232), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [1950] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(20), 2, + sym__annotation, + sym_block_comment, + ACTIONS(255), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(253), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2019] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(21), 2, + sym__annotation, + sym_block_comment, + ACTIONS(260), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(257), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2088] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(22), 2, + sym__annotation, + sym_block_comment, + ACTIONS(265), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(263), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2157] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(23), 2, + sym__annotation, + sym_block_comment, + ACTIONS(269), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(267), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2226] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(24), 2, + sym__annotation, + sym_block_comment, + ACTIONS(273), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(271), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2295] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(25), 2, + sym__annotation, + sym_block_comment, + ACTIONS(277), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(275), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2364] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(26), 2, + sym__annotation, + sym_block_comment, + ACTIONS(281), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(279), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2433] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(27), 2, + sym__annotation, + sym_block_comment, + ACTIONS(285), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(283), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2502] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(28), 2, + sym__annotation, + sym_block_comment, + ACTIONS(289), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(287), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2571] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(29), 2, + sym__annotation, + sym_block_comment, + ACTIONS(293), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(291), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2640] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(30), 2, + sym__annotation, + sym_block_comment, + ACTIONS(297), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(295), 47, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2709] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(31), 2, + sym__annotation, + sym_block_comment, + ACTIONS(269), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(267), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2777] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(32), 2, + sym__annotation, + sym_block_comment, + ACTIONS(285), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(283), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2845] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(33), 2, + sym__annotation, + sym_block_comment, + ACTIONS(260), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(257), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2913] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(34), 2, + sym__annotation, + sym_block_comment, + ACTIONS(255), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(253), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [2981] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(35), 2, + sym__annotation, + sym_block_comment, + ACTIONS(260), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(257), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3049] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(36), 2, + sym__annotation, + sym_block_comment, + ACTIONS(297), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(295), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3117] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(37), 2, + sym__annotation, + sym_block_comment, + ACTIONS(289), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(287), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3185] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(38), 2, + sym__annotation, + sym_block_comment, + ACTIONS(265), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(263), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3253] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(39), 2, + sym__annotation, + sym_block_comment, + ACTIONS(297), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(295), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3321] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(40), 2, + sym__annotation, + sym_block_comment, + ACTIONS(289), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(287), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3389] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(41), 2, + sym__annotation, + sym_block_comment, + ACTIONS(269), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(267), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3457] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(42), 2, + sym__annotation, + sym_block_comment, + ACTIONS(293), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(291), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3525] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(43), 2, + sym__annotation, + sym_block_comment, + ACTIONS(273), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(271), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3593] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(44), 2, + sym__annotation, + sym_block_comment, + ACTIONS(265), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(263), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3661] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(45), 2, + sym__annotation, + sym_block_comment, + ACTIONS(293), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(291), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3729] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(46), 2, + sym__annotation, + sym_block_comment, + ACTIONS(277), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(275), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3797] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(47), 2, + sym__annotation, + sym_block_comment, + ACTIONS(273), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(271), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3865] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(48), 2, + sym__annotation, + sym_block_comment, + ACTIONS(277), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(275), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [3933] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(49), 2, + sym__annotation, + sym_block_comment, + ACTIONS(281), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(279), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [4001] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(50), 2, + sym__annotation, + sym_block_comment, + ACTIONS(285), 4, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(283), 46, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [4069] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 2, + sym__annotation, + sym_block_comment, + ACTIONS(255), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(253), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [4137] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(52), 2, + sym__annotation, + sym_block_comment, + ACTIONS(281), 5, + anon_sym_RPAREN, + sym_identifier, + aux_sym_float_token2, + sym_mem_arg, + sym_string, + ACTIONS(279), 45, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_instr_name, + sym_integer, + aux_sym_float_token1, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_uinteger, + [4205] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(53), 2, + sym__annotation, + sym_block_comment, + ACTIONS(263), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(265), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4266] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(54), 2, + sym__annotation, + sym_block_comment, + ACTIONS(271), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(273), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4327] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(55), 2, + sym__annotation, + sym_block_comment, + ACTIONS(279), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(281), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4388] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(56), 2, + sym__annotation, + sym_block_comment, + ACTIONS(257), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(260), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4449] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(57), 2, + sym__annotation, + sym_block_comment, + ACTIONS(295), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(297), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4510] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(58), 2, + sym__annotation, + sym_block_comment, + ACTIONS(287), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(289), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4571] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(59), 2, + sym__annotation, + sym_block_comment, + ACTIONS(267), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(269), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4632] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(60), 2, + sym__annotation, + sym_block_comment, + ACTIONS(275), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(277), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4693] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(61), 2, + sym__annotation, + sym_block_comment, + ACTIONS(253), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(255), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4754] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(62), 2, + sym__annotation, + sym_block_comment, + ACTIONS(283), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(285), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4815] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(63), 2, + sym__annotation, + sym_block_comment, + ACTIONS(291), 12, + anon_sym_LPAREN, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_exn, + anon_sym_extern, + sym_integer, + sym_uinteger, + ACTIONS(293), 31, + anon_sym_RPAREN, + anon_sym_none, + anon_sym_nofunc, + anon_sym_noexn, + anon_sym_noextern, + anon_sym_nocont, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + aux_sym_float_token1, + aux_sym_float_token2, + sym_mem_arg, + anon_sym_i8x16, + anon_sym_i16x8, + anon_sym_i32x4, + anon_sym_i64x2, + anon_sym_f32x4, + anon_sym_f64x2, + sym_string, + [4876] = 32, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(299), 1, + anon_sym_LPAREN, + ACTIONS(301), 1, + anon_sym_RPAREN, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(313), 1, + sym_identifier, + ACTIONS(315), 1, + sym_instr_name, + STATE(68), 1, + aux_sym_module_field_func_repeat1, + STATE(84), 1, + sym_import, + STATE(123), 1, + sym_type_use, + STATE(128), 1, + aux_sym_block_block_repeat1, + STATE(225), 1, + aux_sym_block_block_repeat2, + STATE(347), 1, + aux_sym_module_field_func_repeat2, + STATE(492), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1078), 1, + sym_export, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(64), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [4980] = 22, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(317), 1, + anon_sym_LPAREN, + ACTIONS(319), 1, + anon_sym_RPAREN, + ACTIONS(322), 1, + anon_sym_func, + ACTIONS(324), 1, + anon_sym_declare, + STATE(597), 1, + sym_offset, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(805), 1, + sym_ref_type, + STATE(1133), 1, + sym_table_use, + STATE(1241), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1561), 1, + sym_elem_list, + ACTIONS(328), 2, + sym_identifier, + sym_uinteger, + STATE(65), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [5063] = 31, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(299), 1, + anon_sym_LPAREN, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + STATE(67), 1, + aux_sym_module_field_func_repeat1, + STATE(89), 1, + sym_import, + STATE(115), 1, + sym_type_use, + STATE(116), 1, + aux_sym_block_block_repeat1, + STATE(209), 1, + aux_sym_block_block_repeat2, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1078), 1, + sym_export, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(66), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5164] = 31, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(299), 1, + anon_sym_LPAREN, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + STATE(110), 1, + sym_import, + STATE(126), 1, + sym_type_use, + STATE(127), 1, + aux_sym_block_block_repeat1, + STATE(216), 1, + aux_sym_block_block_repeat2, + STATE(353), 1, + aux_sym_module_field_func_repeat2, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(835), 1, + aux_sym_module_field_func_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1078), 1, + sym_export, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(67), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5265] = 31, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(299), 1, + anon_sym_LPAREN, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + STATE(89), 1, + sym_import, + STATE(115), 1, + sym_type_use, + STATE(116), 1, + aux_sym_block_block_repeat1, + STATE(209), 1, + aux_sym_block_block_repeat2, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(835), 1, + aux_sym_module_field_func_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1078), 1, + sym_export, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(68), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5366] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(317), 1, + anon_sym_LPAREN, + ACTIONS(322), 1, + anon_sym_func, + ACTIONS(335), 1, + anon_sym_RPAREN, + ACTIONS(337), 1, + anon_sym_declare, + ACTIONS(339), 1, + sym_identifier, + ACTIONS(341), 1, + sym_uinteger, + STATE(648), 1, + sym_offset, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(805), 1, + sym_ref_type, + STATE(1056), 1, + sym_table_use, + STATE(1241), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1610), 1, + sym_elem_list, + STATE(69), 2, + sym__annotation, + sym_block_comment, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [5451] = 30, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(347), 1, + anon_sym_end, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(359), 1, + sym_identifier, + ACTIONS(361), 1, + sym_instr_name, + STATE(98), 1, + sym_type_use, + STATE(99), 1, + aux_sym_block_block_repeat1, + STATE(200), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1374), 1, + sym_block_if_then, + STATE(1472), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(70), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5549] = 30, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(363), 1, + anon_sym_end, + ACTIONS(365), 1, + sym_identifier, + STATE(93), 1, + aux_sym_block_block_repeat1, + STATE(95), 1, + sym_type_use, + STATE(199), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1309), 1, + sym_block_if_then, + STATE(1485), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(71), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5647] = 30, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(367), 1, + anon_sym_end, + ACTIONS(369), 1, + sym_identifier, + STATE(86), 1, + aux_sym_block_block_repeat1, + STATE(106), 1, + sym_type_use, + STATE(177), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1335), 1, + sym_block_if_then, + STATE(1628), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(72), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5745] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(375), 1, + anon_sym_end, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(385), 1, + sym_identifier, + ACTIONS(387), 1, + sym_instr_name, + STATE(113), 1, + sym_type_use, + STATE(114), 1, + aux_sym_block_block_repeat1, + STATE(222), 1, + aux_sym_block_block_repeat2, + STATE(354), 1, + aux_sym_block_try_table_repeat1, + STATE(556), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(73), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5840] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(391), 1, + anon_sym_RPAREN, + ACTIONS(393), 1, + sym_identifier, + STATE(164), 1, + sym_type_use, + STATE(165), 1, + aux_sym_block_block_repeat1, + STATE(299), 1, + aux_sym_block_block_repeat2, + STATE(437), 1, + aux_sym_block_try_table_repeat1, + STATE(591), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(74), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [5935] = 16, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(397), 1, + anon_sym_LPAREN, + ACTIONS(399), 1, + anon_sym_RPAREN, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(407), 1, + sym_identifier, + STATE(94), 1, + aux_sym_field_repeat1, + STATE(478), 1, + sym__storage_type, + STATE(548), 1, + sym_field_type, + ACTIONS(401), 2, + anon_sym_i8, + anon_sym_i16, + STATE(75), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + STATE(652), 2, + sym_packed_type, + sym__value_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [6004] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(409), 1, + anon_sym_end, + ACTIONS(411), 1, + sym_identifier, + STATE(134), 1, + sym_type_use, + STATE(135), 1, + aux_sym_block_block_repeat1, + STATE(271), 1, + aux_sym_block_block_repeat2, + STATE(356), 1, + aux_sym_block_try_table_repeat1, + STATE(604), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(76), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6099] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(413), 1, + anon_sym_RPAREN, + ACTIONS(415), 1, + sym_identifier, + STATE(137), 1, + sym_type_use, + STATE(138), 1, + aux_sym_block_block_repeat1, + STATE(293), 1, + aux_sym_block_block_repeat2, + STATE(359), 1, + aux_sym_block_try_table_repeat1, + STATE(479), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(77), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6194] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(417), 1, + anon_sym_end, + STATE(90), 1, + sym_type_use, + STATE(91), 1, + aux_sym_block_block_repeat1, + STATE(205), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1325), 1, + sym_block_if_then, + STATE(1567), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(78), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6289] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(419), 1, + anon_sym_RPAREN, + ACTIONS(421), 1, + sym_identifier, + STATE(121), 1, + sym_type_use, + STATE(122), 1, + aux_sym_block_block_repeat1, + STATE(265), 1, + aux_sym_block_block_repeat2, + STATE(342), 1, + aux_sym_block_try_table_repeat1, + STATE(618), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(79), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6384] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(423), 1, + anon_sym_end, + ACTIONS(425), 1, + sym_identifier, + STATE(151), 1, + sym_type_use, + STATE(152), 1, + aux_sym_block_block_repeat1, + STATE(245), 1, + aux_sym_block_block_repeat2, + STATE(397), 1, + aux_sym_block_try_table_repeat1, + STATE(493), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(80), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6479] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_RPAREN, + ACTIONS(429), 1, + sym_identifier, + STATE(153), 1, + sym_type_use, + STATE(154), 1, + aux_sym_block_block_repeat1, + STATE(255), 1, + aux_sym_block_block_repeat2, + STATE(402), 1, + aux_sym_block_try_table_repeat1, + STATE(506), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(81), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6574] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(431), 1, + anon_sym_end, + STATE(103), 1, + sym_type_use, + STATE(104), 1, + aux_sym_block_block_repeat1, + STATE(180), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1302), 1, + sym_block_if_then, + STATE(1465), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(82), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6669] = 29, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(343), 1, + anon_sym_LPAREN, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(433), 1, + anon_sym_end, + STATE(107), 1, + sym_type_use, + STATE(109), 1, + aux_sym_block_block_repeat1, + STATE(187), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1375), 1, + sym_block_if_then, + STATE(1512), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(83), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6764] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(435), 1, + anon_sym_LPAREN, + STATE(115), 1, + sym_type_use, + STATE(116), 1, + aux_sym_block_block_repeat1, + STATE(209), 1, + aux_sym_block_block_repeat2, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(84), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6856] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_end, + STATE(191), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1315), 1, + sym_block_if_then, + STATE(1513), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(85), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [6948] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(417), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(205), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1325), 1, + sym_block_if_then, + STATE(1567), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(86), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7040] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + STATE(139), 1, + sym_type_use, + STATE(140), 1, + aux_sym_block_block_repeat1, + STATE(321), 1, + aux_sym_block_block_repeat2, + STATE(366), 1, + aux_sym_block_try_table_repeat1, + STATE(516), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(87), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7132] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(443), 1, + anon_sym_RPAREN, + STATE(141), 1, + sym_type_use, + STATE(142), 1, + aux_sym_block_block_repeat1, + STATE(211), 1, + aux_sym_block_block_repeat2, + STATE(371), 1, + aux_sym_block_try_table_repeat1, + STATE(542), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(88), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7224] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(435), 1, + anon_sym_LPAREN, + STATE(126), 1, + sym_type_use, + STATE(127), 1, + aux_sym_block_block_repeat1, + STATE(216), 1, + aux_sym_block_block_repeat2, + STATE(353), 1, + aux_sym_module_field_func_repeat2, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(89), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7316] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(445), 1, + anon_sym_end, + STATE(92), 1, + aux_sym_block_block_repeat1, + STATE(182), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1382), 1, + sym_block_if_then, + STATE(1568), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(90), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7408] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(445), 1, + anon_sym_end, + STATE(182), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1382), 1, + sym_block_if_then, + STATE(1568), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(91), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7500] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(447), 1, + anon_sym_end, + STATE(186), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1407), 1, + sym_block_if_then, + STATE(1474), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(92), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7592] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(433), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(187), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1375), 1, + sym_block_if_then, + STATE(1512), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(93), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7684] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(397), 1, + anon_sym_LPAREN, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(449), 1, + anon_sym_RPAREN, + STATE(102), 1, + aux_sym_field_repeat1, + STATE(478), 1, + sym__storage_type, + STATE(548), 1, + sym_field_type, + ACTIONS(401), 2, + anon_sym_i8, + anon_sym_i16, + STATE(94), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + STATE(652), 2, + sym_packed_type, + sym__value_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [7750] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(433), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(109), 1, + aux_sym_block_block_repeat1, + STATE(187), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1375), 1, + sym_block_if_then, + STATE(1512), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(95), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7842] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(451), 1, + anon_sym_RPAREN, + STATE(133), 1, + sym_type_use, + STATE(136), 1, + aux_sym_block_block_repeat1, + STATE(297), 1, + aux_sym_block_block_repeat2, + STATE(372), 1, + aux_sym_block_try_table_repeat1, + STATE(539), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(96), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [7934] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + STATE(124), 1, + sym_type_use, + STATE(125), 1, + aux_sym_block_block_repeat1, + STATE(210), 1, + aux_sym_block_block_repeat2, + STATE(350), 1, + aux_sym_block_try_table_repeat1, + STATE(519), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(97), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8026] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(431), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(104), 1, + aux_sym_block_block_repeat1, + STATE(180), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1302), 1, + sym_block_if_then, + STATE(1465), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(98), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8118] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(431), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(180), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1302), 1, + sym_block_if_then, + STATE(1465), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(99), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8210] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(371), 1, + anon_sym_LPAREN, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + STATE(156), 1, + sym_type_use, + STATE(157), 1, + aux_sym_block_block_repeat1, + STATE(266), 1, + aux_sym_block_block_repeat2, + STATE(409), 1, + aux_sym_block_try_table_repeat1, + STATE(521), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(100), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8302] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(457), 1, + anon_sym_RPAREN, + STATE(158), 1, + sym_type_use, + STATE(159), 1, + aux_sym_block_block_repeat1, + STATE(273), 1, + aux_sym_block_block_repeat2, + STATE(414), 1, + aux_sym_block_try_table_repeat1, + STATE(532), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(101), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8394] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(462), 1, + anon_sym_LPAREN, + ACTIONS(465), 1, + anon_sym_RPAREN, + ACTIONS(473), 1, + sym_vec_type, + STATE(478), 1, + sym__storage_type, + STATE(548), 1, + sym_field_type, + ACTIONS(467), 2, + anon_sym_i8, + anon_sym_i16, + STATE(518), 2, + sym_num_type, + sym_ref_type, + STATE(652), 2, + sym_packed_type, + sym__value_type, + STATE(102), 3, + sym__annotation, + sym_block_comment, + aux_sym_field_repeat1, + ACTIONS(459), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(470), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [8458] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(476), 1, + anon_sym_end, + STATE(105), 1, + aux_sym_block_block_repeat1, + STATE(185), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1319), 1, + sym_block_if_then, + STATE(1538), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(103), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8550] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(476), 1, + anon_sym_end, + STATE(185), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1319), 1, + sym_block_if_then, + STATE(1538), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(104), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8642] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(478), 1, + anon_sym_end, + STATE(188), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1332), 1, + sym_block_if_then, + STATE(1596), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(105), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8734] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(417), 1, + anon_sym_end, + ACTIONS(437), 1, + anon_sym_LPAREN, + STATE(91), 1, + aux_sym_block_block_repeat1, + STATE(205), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1325), 1, + sym_block_if_then, + STATE(1567), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(106), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8826] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(480), 1, + anon_sym_end, + STATE(85), 1, + aux_sym_block_block_repeat1, + STATE(181), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1296), 1, + sym_block_if_then, + STATE(1590), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(107), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [8918] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(389), 1, + anon_sym_LPAREN, + ACTIONS(482), 1, + anon_sym_RPAREN, + STATE(167), 1, + sym_type_use, + STATE(168), 1, + aux_sym_block_block_repeat1, + STATE(307), 1, + aux_sym_block_block_repeat2, + STATE(442), 1, + aux_sym_block_try_table_repeat1, + STATE(603), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(108), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9010] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(437), 1, + anon_sym_LPAREN, + ACTIONS(480), 1, + anon_sym_end, + STATE(181), 1, + aux_sym_block_block_repeat2, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(871), 1, + sym_param, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1296), 1, + sym_block_if_then, + STATE(1590), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(109), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9102] = 28, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(484), 1, + anon_sym_RPAREN, + STATE(149), 1, + aux_sym_block_block_repeat1, + STATE(150), 1, + sym_type_use, + STATE(236), 1, + aux_sym_block_block_repeat2, + STATE(392), 1, + aux_sym_module_field_func_repeat2, + STATE(477), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(110), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9194] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(488), 1, + anon_sym_RPAREN, + ACTIONS(490), 1, + sym_identifier, + STATE(238), 1, + sym_type_use, + STATE(249), 1, + aux_sym_block_block_repeat1, + STATE(340), 1, + aux_sym_block_block_repeat2, + STATE(500), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(111), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9283] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + ACTIONS(494), 1, + sym_identifier, + STATE(329), 1, + sym_type_use, + STATE(330), 1, + aux_sym_block_block_repeat1, + STATE(460), 1, + aux_sym_block_block_repeat2, + STATE(653), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1347), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(112), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9372] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(125), 1, + aux_sym_block_block_repeat1, + STATE(210), 1, + aux_sym_block_block_repeat2, + STATE(350), 1, + aux_sym_block_try_table_repeat1, + STATE(519), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(113), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9461] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(210), 1, + aux_sym_block_block_repeat2, + STATE(350), 1, + aux_sym_block_try_table_repeat1, + STATE(519), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(114), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9550] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(127), 1, + aux_sym_block_block_repeat1, + STATE(216), 1, + aux_sym_block_block_repeat2, + STATE(353), 1, + aux_sym_module_field_func_repeat2, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(115), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9639] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(216), 1, + aux_sym_block_block_repeat2, + STATE(353), 1, + aux_sym_module_field_func_repeat2, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(116), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9728] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(500), 1, + anon_sym_RPAREN, + ACTIONS(502), 1, + sym_identifier, + STATE(214), 1, + sym_type_use, + STATE(220), 1, + aux_sym_block_block_repeat1, + STATE(441), 1, + aux_sym_block_block_repeat2, + STATE(651), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(117), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9817] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + ACTIONS(504), 1, + sym_identifier, + STATE(227), 1, + sym_type_use, + STATE(229), 1, + aux_sym_block_block_repeat1, + STATE(339), 1, + aux_sym_block_block_repeat2, + STATE(490), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1346), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(118), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9906] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(508), 1, + anon_sym_end, + ACTIONS(510), 1, + sym_identifier, + STATE(234), 1, + sym_type_use, + STATE(261), 1, + aux_sym_block_block_repeat1, + STATE(348), 1, + aux_sym_block_block_repeat2, + STATE(517), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(119), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [9995] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(512), 1, + anon_sym_end, + ACTIONS(514), 1, + sym_identifier, + STATE(272), 1, + sym_type_use, + STATE(289), 1, + aux_sym_block_block_repeat1, + STATE(341), 1, + aux_sym_block_block_repeat2, + STATE(561), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(120), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10084] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(451), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(136), 1, + aux_sym_block_block_repeat1, + STATE(297), 1, + aux_sym_block_block_repeat2, + STATE(372), 1, + aux_sym_block_try_table_repeat1, + STATE(539), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(121), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10173] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(451), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(297), 1, + aux_sym_block_block_repeat2, + STATE(372), 1, + aux_sym_block_try_table_repeat1, + STATE(539), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(122), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10262] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(116), 1, + aux_sym_block_block_repeat1, + STATE(209), 1, + aux_sym_block_block_repeat2, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(123), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10351] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(518), 1, + anon_sym_end, + STATE(146), 1, + aux_sym_block_block_repeat1, + STATE(231), 1, + aux_sym_block_block_repeat2, + STATE(390), 1, + aux_sym_block_try_table_repeat1, + STATE(657), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(124), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10440] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(518), 1, + anon_sym_end, + STATE(231), 1, + aux_sym_block_block_repeat2, + STATE(390), 1, + aux_sym_block_try_table_repeat1, + STATE(657), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(125), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10529] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(484), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(149), 1, + aux_sym_block_block_repeat1, + STATE(236), 1, + aux_sym_block_block_repeat2, + STATE(392), 1, + aux_sym_module_field_func_repeat2, + STATE(477), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(126), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10618] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(484), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(236), 1, + aux_sym_block_block_repeat2, + STATE(392), 1, + aux_sym_module_field_func_repeat2, + STATE(477), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(127), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10707] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(498), 1, + anon_sym_LPAREN, + STATE(209), 1, + aux_sym_block_block_repeat2, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(128), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10796] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(520), 1, + anon_sym_end, + ACTIONS(522), 1, + sym_identifier, + STATE(239), 1, + sym_type_use, + STATE(242), 1, + aux_sym_block_block_repeat1, + STATE(352), 1, + aux_sym_block_block_repeat2, + STATE(537), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(129), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10885] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(524), 1, + anon_sym_end, + ACTIONS(526), 1, + sym_identifier, + STATE(254), 1, + sym_type_use, + STATE(260), 1, + aux_sym_block_block_repeat1, + STATE(355), 1, + aux_sym_block_block_repeat2, + STATE(570), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(130), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [10974] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(528), 1, + anon_sym_RPAREN, + ACTIONS(530), 1, + sym_identifier, + STATE(278), 1, + aux_sym_block_block_repeat1, + STATE(333), 1, + sym_type_use, + STATE(357), 1, + aux_sym_block_block_repeat2, + STATE(631), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(131), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11063] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(532), 1, + anon_sym_RPAREN, + ACTIONS(534), 1, + sym_identifier, + STATE(284), 1, + sym_type_use, + STATE(287), 1, + aux_sym_block_block_repeat1, + STATE(358), 1, + aux_sym_block_block_repeat2, + STATE(575), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(132), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11152] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(536), 1, + anon_sym_RPAREN, + STATE(155), 1, + aux_sym_block_block_repeat1, + STATE(275), 1, + aux_sym_block_block_repeat2, + STATE(406), 1, + aux_sym_block_try_table_repeat1, + STATE(515), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(133), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11241] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(140), 1, + aux_sym_block_block_repeat1, + STATE(321), 1, + aux_sym_block_block_repeat2, + STATE(366), 1, + aux_sym_block_try_table_repeat1, + STATE(516), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(134), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11330] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(321), 1, + aux_sym_block_block_repeat2, + STATE(366), 1, + aux_sym_block_try_table_repeat1, + STATE(516), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(135), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11419] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(536), 1, + anon_sym_RPAREN, + STATE(275), 1, + aux_sym_block_block_repeat2, + STATE(406), 1, + aux_sym_block_try_table_repeat1, + STATE(515), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(136), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11508] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(443), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(142), 1, + aux_sym_block_block_repeat1, + STATE(211), 1, + aux_sym_block_block_repeat2, + STATE(371), 1, + aux_sym_block_try_table_repeat1, + STATE(542), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(137), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11597] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(443), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(211), 1, + aux_sym_block_block_repeat2, + STATE(371), 1, + aux_sym_block_try_table_repeat1, + STATE(542), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(138), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11686] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(538), 1, + anon_sym_end, + STATE(143), 1, + aux_sym_block_block_repeat1, + STATE(217), 1, + aux_sym_block_block_repeat2, + STATE(375), 1, + aux_sym_block_try_table_repeat1, + STATE(555), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(139), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11775] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(538), 1, + anon_sym_end, + STATE(217), 1, + aux_sym_block_block_repeat2, + STATE(375), 1, + aux_sym_block_try_table_repeat1, + STATE(555), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(140), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11864] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(540), 1, + anon_sym_RPAREN, + STATE(172), 1, + aux_sym_block_block_repeat1, + STATE(221), 1, + aux_sym_block_block_repeat2, + STATE(380), 1, + aux_sym_block_try_table_repeat1, + STATE(580), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(141), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [11953] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(540), 1, + anon_sym_RPAREN, + STATE(221), 1, + aux_sym_block_block_repeat2, + STATE(380), 1, + aux_sym_block_try_table_repeat1, + STATE(580), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(142), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12042] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(542), 1, + anon_sym_end, + STATE(223), 1, + aux_sym_block_block_repeat2, + STATE(383), 1, + aux_sym_block_try_table_repeat1, + STATE(601), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(143), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12131] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(544), 1, + anon_sym_end, + ACTIONS(546), 1, + sym_identifier, + STATE(206), 1, + sym_type_use, + STATE(235), 1, + aux_sym_block_block_repeat1, + STATE(393), 1, + aux_sym_block_block_repeat2, + STATE(480), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(144), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12220] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(548), 1, + anon_sym_end, + ACTIONS(550), 1, + sym_identifier, + STATE(240), 1, + sym_type_use, + STATE(241), 1, + aux_sym_block_block_repeat1, + STATE(395), 1, + aux_sym_block_block_repeat2, + STATE(489), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(145), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12309] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(552), 1, + anon_sym_end, + STATE(290), 1, + aux_sym_block_block_repeat2, + STATE(413), 1, + aux_sym_block_try_table_repeat1, + STATE(529), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(146), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12398] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(554), 1, + anon_sym_RPAREN, + ACTIONS(556), 1, + sym_identifier, + STATE(247), 1, + sym_type_use, + STATE(248), 1, + aux_sym_block_block_repeat1, + STATE(464), 1, + aux_sym_block_block_repeat2, + STATE(498), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(147), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12487] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(558), 1, + anon_sym_RPAREN, + ACTIONS(560), 1, + sym_identifier, + STATE(250), 1, + sym_type_use, + STATE(251), 1, + aux_sym_block_block_repeat1, + STATE(400), 1, + aux_sym_block_block_repeat2, + STATE(503), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(148), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12576] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(498), 1, + anon_sym_LPAREN, + ACTIONS(562), 1, + anon_sym_RPAREN, + STATE(296), 1, + aux_sym_block_block_repeat2, + STATE(416), 1, + aux_sym_module_field_func_repeat2, + STATE(534), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(149), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12665] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(498), 1, + anon_sym_LPAREN, + ACTIONS(562), 1, + anon_sym_RPAREN, + STATE(166), 1, + aux_sym_block_block_repeat1, + STATE(296), 1, + aux_sym_block_block_repeat2, + STATE(416), 1, + aux_sym_module_field_func_repeat2, + STATE(534), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(150), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12754] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(157), 1, + aux_sym_block_block_repeat1, + STATE(266), 1, + aux_sym_block_block_repeat2, + STATE(409), 1, + aux_sym_block_try_table_repeat1, + STATE(521), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(151), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12843] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + ACTIONS(496), 1, + anon_sym_LPAREN, + STATE(266), 1, + aux_sym_block_block_repeat2, + STATE(409), 1, + aux_sym_block_try_table_repeat1, + STATE(521), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(152), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [12932] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(457), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(159), 1, + aux_sym_block_block_repeat1, + STATE(273), 1, + aux_sym_block_block_repeat2, + STATE(414), 1, + aux_sym_block_try_table_repeat1, + STATE(532), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(153), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13021] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(457), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(273), 1, + aux_sym_block_block_repeat2, + STATE(414), 1, + aux_sym_block_try_table_repeat1, + STATE(532), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(154), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13110] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(564), 1, + anon_sym_RPAREN, + STATE(276), 1, + aux_sym_block_block_repeat2, + STATE(435), 1, + aux_sym_block_try_table_repeat1, + STATE(584), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(155), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13199] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(566), 1, + anon_sym_end, + STATE(160), 1, + aux_sym_block_block_repeat1, + STATE(279), 1, + aux_sym_block_block_repeat2, + STATE(418), 1, + aux_sym_block_try_table_repeat1, + STATE(543), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(156), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13288] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(566), 1, + anon_sym_end, + STATE(279), 1, + aux_sym_block_block_repeat2, + STATE(418), 1, + aux_sym_block_try_table_repeat1, + STATE(543), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(157), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13377] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(568), 1, + anon_sym_RPAREN, + STATE(161), 1, + aux_sym_block_block_repeat1, + STATE(283), 1, + aux_sym_block_block_repeat2, + STATE(422), 1, + aux_sym_block_try_table_repeat1, + STATE(551), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(158), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13466] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(568), 1, + anon_sym_RPAREN, + STATE(283), 1, + aux_sym_block_block_repeat2, + STATE(422), 1, + aux_sym_block_try_table_repeat1, + STATE(551), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(159), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13555] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(496), 1, + anon_sym_LPAREN, + ACTIONS(570), 1, + anon_sym_end, + STATE(285), 1, + aux_sym_block_block_repeat2, + STATE(426), 1, + aux_sym_block_try_table_repeat1, + STATE(559), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(160), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13644] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(572), 1, + anon_sym_RPAREN, + STATE(286), 1, + aux_sym_block_block_repeat2, + STATE(429), 1, + aux_sym_block_try_table_repeat1, + STATE(565), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(161), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13733] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(574), 1, + anon_sym_RPAREN, + ACTIONS(576), 1, + sym_identifier, + STATE(291), 1, + sym_type_use, + STATE(292), 1, + aux_sym_block_block_repeat1, + STATE(434), 1, + aux_sym_block_block_repeat2, + STATE(583), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(162), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13822] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(578), 1, + anon_sym_RPAREN, + ACTIONS(580), 1, + sym_identifier, + STATE(294), 1, + sym_type_use, + STATE(295), 1, + aux_sym_block_block_repeat1, + STATE(436), 1, + aux_sym_block_block_repeat2, + STATE(587), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(163), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [13911] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(482), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(168), 1, + aux_sym_block_block_repeat1, + STATE(307), 1, + aux_sym_block_block_repeat2, + STATE(442), 1, + aux_sym_block_try_table_repeat1, + STATE(603), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(164), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14000] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(482), 1, + anon_sym_RPAREN, + ACTIONS(516), 1, + anon_sym_LPAREN, + STATE(307), 1, + aux_sym_block_block_repeat2, + STATE(442), 1, + aux_sym_block_try_table_repeat1, + STATE(603), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(165), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14089] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(498), 1, + anon_sym_LPAREN, + ACTIONS(582), 1, + anon_sym_RPAREN, + STATE(264), 1, + aux_sym_block_block_repeat2, + STATE(439), 1, + aux_sym_module_field_func_repeat2, + STATE(594), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(166), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14178] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(584), 1, + anon_sym_RPAREN, + STATE(169), 1, + aux_sym_block_block_repeat1, + STATE(311), 1, + aux_sym_block_block_repeat2, + STATE(445), 1, + aux_sym_block_try_table_repeat1, + STATE(611), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(167), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14267] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(584), 1, + anon_sym_RPAREN, + STATE(311), 1, + aux_sym_block_block_repeat2, + STATE(445), 1, + aux_sym_block_try_table_repeat1, + STATE(611), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(168), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14356] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(586), 1, + anon_sym_RPAREN, + STATE(312), 1, + aux_sym_block_block_repeat2, + STATE(448), 1, + aux_sym_block_try_table_repeat1, + STATE(617), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(169), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14445] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + ACTIONS(588), 1, + sym_identifier, + STATE(315), 1, + sym_type_use, + STATE(316), 1, + aux_sym_block_block_repeat1, + STATE(451), 1, + aux_sym_block_block_repeat2, + STATE(628), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1294), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(170), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14534] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + ACTIONS(590), 1, + sym_identifier, + STATE(322), 1, + sym_type_use, + STATE(323), 1, + aux_sym_block_block_repeat1, + STATE(456), 1, + aux_sym_block_block_repeat2, + STATE(641), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1292), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(171), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14623] = 27, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(516), 1, + anon_sym_LPAREN, + ACTIONS(592), 1, + anon_sym_RPAREN, + STATE(224), 1, + aux_sym_block_block_repeat2, + STATE(386), 1, + aux_sym_block_try_table_repeat1, + STATE(615), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(172), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14712] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(594), 1, + anon_sym_RPAREN, + STATE(327), 1, + sym_type_use, + STATE(328), 1, + aux_sym_block_block_repeat1, + STATE(368), 1, + aux_sym_block_block_repeat2, + STATE(524), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(173), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14798] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(596), 1, + anon_sym_end, + STATE(298), 1, + sym_type_use, + STATE(300), 1, + aux_sym_block_block_repeat1, + STATE(363), 1, + aux_sym_block_block_repeat2, + STATE(502), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(174), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14884] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(598), 1, + anon_sym_RPAREN, + STATE(267), 1, + sym_type_use, + STATE(268), 1, + aux_sym_block_block_repeat1, + STATE(411), 1, + aux_sym_block_block_repeat2, + STATE(525), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(175), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [14970] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(600), 1, + anon_sym_RPAREN, + STATE(269), 1, + sym_type_use, + STATE(270), 1, + aux_sym_block_block_repeat1, + STATE(412), 1, + aux_sym_block_block_repeat2, + STATE(528), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(176), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15056] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(417), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1325), 1, + sym_block_if_then, + STATE(1567), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(177), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15142] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(604), 1, + anon_sym_end, + STATE(310), 1, + sym_type_use, + STATE(313), 1, + aux_sym_block_block_repeat1, + STATE(365), 1, + aux_sym_block_block_repeat2, + STATE(512), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(178), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15228] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(606), 1, + anon_sym_RPAREN, + STATE(228), 1, + sym_type_use, + STATE(232), 1, + aux_sym_block_block_repeat1, + STATE(360), 1, + aux_sym_block_block_repeat2, + STATE(494), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(179), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15314] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(476), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1319), 1, + sym_block_if_then, + STATE(1538), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(180), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15400] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(439), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1315), 1, + sym_block_if_then, + STATE(1513), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(181), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15486] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(447), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1407), 1, + sym_block_if_then, + STATE(1474), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(182), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15572] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + STATE(233), 1, + sym_type_use, + STATE(243), 1, + aux_sym_block_block_repeat1, + STATE(364), 1, + aux_sym_block_block_repeat2, + STATE(509), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1314), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(183), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15658] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + STATE(331), 1, + sym_type_use, + STATE(332), 1, + aux_sym_block_block_repeat1, + STATE(461), 1, + aux_sym_block_block_repeat2, + STATE(655), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1355), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(184), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15744] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(478), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1332), 1, + sym_block_if_then, + STATE(1596), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(185), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15830] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(602), 1, + anon_sym_LPAREN, + ACTIONS(608), 1, + anon_sym_end, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1291), 1, + sym_block_if_then, + STATE(1576), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(186), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [15916] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(480), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1296), 1, + sym_block_if_then, + STATE(1590), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(187), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16002] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(602), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_end, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1340), 1, + sym_block_if_then, + STATE(1633), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(188), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16088] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(614), 1, + anon_sym_LPAREN, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(618), 1, + sym_identifier, + STATE(213), 1, + aux_sym_module_field_func_repeat1, + STATE(467), 1, + sym_import, + STATE(544), 1, + sym_global_type, + STATE(663), 1, + sym_export, + STATE(1097), 1, + sym__value_type, + STATE(189), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [16152] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(620), 1, + anon_sym_RPAREN, + STATE(207), 1, + sym_type_use, + STATE(208), 1, + aux_sym_block_block_repeat1, + STATE(369), 1, + aux_sym_block_block_repeat2, + STATE(533), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(190), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16238] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(602), 1, + anon_sym_LPAREN, + ACTIONS(622), 1, + anon_sym_end, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1356), 1, + sym_block_if_then, + STATE(1498), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(191), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16324] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(624), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym_type_use, + STATE(302), 1, + aux_sym_block_block_repeat1, + STATE(338), 1, + aux_sym_block_block_repeat2, + STATE(596), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(192), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16410] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(626), 1, + anon_sym_RPAREN, + STATE(304), 1, + sym_type_use, + STATE(305), 1, + aux_sym_block_block_repeat1, + STATE(440), 1, + aux_sym_block_block_repeat2, + STATE(600), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(193), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16496] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(486), 1, + anon_sym_LPAREN, + ACTIONS(628), 1, + anon_sym_RPAREN, + STATE(244), 1, + sym_type_use, + STATE(246), 1, + aux_sym_block_block_repeat1, + STATE(367), 1, + aux_sym_block_block_repeat2, + STATE(522), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(194), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16582] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(630), 1, + anon_sym_end, + STATE(282), 1, + sym_type_use, + STATE(288), 1, + aux_sym_block_block_repeat1, + STATE(346), 1, + aux_sym_block_block_repeat2, + STATE(659), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(195), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16668] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(632), 1, + anon_sym_LPAREN, + STATE(478), 1, + sym__storage_type, + STATE(1619), 1, + sym_field_type, + ACTIONS(401), 2, + anon_sym_i8, + anon_sym_i16, + STATE(196), 2, + sym__annotation, + sym_block_comment, + STATE(652), 2, + sym_packed_type, + sym__value_type, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [16728] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(632), 1, + anon_sym_LPAREN, + STATE(478), 1, + sym__storage_type, + STATE(1541), 1, + sym_field_type, + ACTIONS(401), 2, + anon_sym_i8, + anon_sym_i16, + STATE(197), 2, + sym__annotation, + sym_block_comment, + STATE(652), 2, + sym_packed_type, + sym__value_type, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [16788] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_end, + STATE(257), 1, + sym_type_use, + STATE(258), 1, + aux_sym_block_block_repeat1, + STATE(405), 1, + aux_sym_block_block_repeat2, + STATE(513), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(198), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16874] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(433), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1375), 1, + sym_block_if_then, + STATE(1512), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(199), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [16960] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(431), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1302), 1, + sym_block_if_then, + STATE(1465), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(200), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17046] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(636), 1, + anon_sym_end, + STATE(262), 1, + sym_type_use, + STATE(263), 1, + aux_sym_block_block_repeat1, + STATE(407), 1, + aux_sym_block_block_repeat2, + STATE(475), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(201), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17132] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + STATE(317), 1, + sym_type_use, + STATE(318), 1, + aux_sym_block_block_repeat1, + STATE(453), 1, + aux_sym_block_block_repeat2, + STATE(633), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1354), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(202), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17218] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(506), 1, + anon_sym_LPAREN, + ACTIONS(638), 1, + anon_sym_end, + STATE(306), 1, + sym_type_use, + STATE(314), 1, + aux_sym_block_block_repeat1, + STATE(349), 1, + aux_sym_block_block_repeat2, + STATE(510), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(203), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17304] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(492), 1, + anon_sym_LPAREN, + STATE(324), 1, + sym_type_use, + STATE(325), 1, + aux_sym_block_block_repeat1, + STATE(457), 1, + aux_sym_block_block_repeat2, + STATE(645), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1312), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(204), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17390] = 26, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(351), 1, + anon_sym_else, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(445), 1, + anon_sym_end, + ACTIONS(602), 1, + anon_sym_LPAREN, + STATE(465), 1, + aux_sym_block_block_repeat3, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + STATE(873), 1, + sym_result, + STATE(1382), 1, + sym_block_if_then, + STATE(1568), 1, + sym_block_if_else, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(205), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17476] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(634), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(258), 1, + aux_sym_block_block_repeat1, + STATE(405), 1, + aux_sym_block_block_repeat2, + STATE(513), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(206), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17559] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(644), 1, + anon_sym_RPAREN, + STATE(219), 1, + aux_sym_block_block_repeat1, + STATE(378), 1, + aux_sym_block_block_repeat2, + STATE(574), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(207), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17642] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(644), 1, + anon_sym_RPAREN, + STATE(378), 1, + aux_sym_block_block_repeat2, + STATE(574), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(208), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17725] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(646), 1, + anon_sym_LPAREN, + STATE(353), 1, + aux_sym_module_field_func_repeat2, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(209), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17808] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(518), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(390), 1, + aux_sym_block_try_table_repeat1, + STATE(657), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(210), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17891] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(540), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(380), 1, + aux_sym_block_try_table_repeat1, + STATE(580), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(211), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [17974] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(652), 1, + anon_sym_end, + STATE(381), 1, + aux_sym_block_block_repeat2, + STATE(586), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(212), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18057] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(614), 1, + anon_sym_LPAREN, + ACTIONS(616), 1, + sym_vec_type, + STATE(471), 1, + sym_import, + STATE(487), 1, + sym_global_type, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(663), 1, + sym_export, + STATE(1097), 1, + sym__value_type, + STATE(213), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [18118] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(606), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(232), 1, + aux_sym_block_block_repeat1, + STATE(360), 1, + aux_sym_block_block_repeat2, + STATE(494), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(214), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18201] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(654), 1, + anon_sym_end, + STATE(382), 1, + aux_sym_block_block_repeat2, + STATE(595), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(215), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18284] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(484), 1, + anon_sym_RPAREN, + ACTIONS(646), 1, + anon_sym_LPAREN, + STATE(392), 1, + aux_sym_module_field_func_repeat2, + STATE(477), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(216), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18367] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(542), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(383), 1, + aux_sym_block_try_table_repeat1, + STATE(601), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(217), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18450] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(656), 1, + anon_sym_RPAREN, + STATE(384), 1, + aux_sym_block_block_repeat2, + STATE(608), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(218), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18533] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(658), 1, + anon_sym_RPAREN, + STATE(385), 1, + aux_sym_block_block_repeat2, + STATE(613), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(219), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18616] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(606), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(360), 1, + aux_sym_block_block_repeat2, + STATE(494), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(220), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18699] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(592), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(386), 1, + aux_sym_block_try_table_repeat1, + STATE(615), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(221), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18782] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(350), 1, + aux_sym_block_try_table_repeat1, + STATE(519), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(222), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18865] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(648), 1, + anon_sym_LPAREN, + ACTIONS(660), 1, + anon_sym_end, + STATE(387), 1, + aux_sym_block_try_table_repeat1, + STATE(627), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(223), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [18948] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(650), 1, + anon_sym_LPAREN, + ACTIONS(662), 1, + anon_sym_RPAREN, + STATE(388), 1, + aux_sym_block_try_table_repeat1, + STATE(636), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(224), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19031] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(646), 1, + anon_sym_LPAREN, + STATE(370), 1, + aux_sym_module_field_func_repeat2, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(225), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19114] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(664), 1, + anon_sym_end, + STATE(410), 1, + aux_sym_block_block_repeat2, + STATE(526), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(226), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19197] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(243), 1, + aux_sym_block_block_repeat1, + STATE(364), 1, + aux_sym_block_block_repeat2, + STATE(509), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1314), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(227), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19280] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(668), 1, + anon_sym_RPAREN, + STATE(252), 1, + aux_sym_block_block_repeat1, + STATE(396), 1, + aux_sym_block_block_repeat2, + STATE(495), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(228), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19363] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(364), 1, + aux_sym_block_block_repeat2, + STATE(509), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1314), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(229), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19446] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(614), 1, + anon_sym_LPAREN, + ACTIONS(616), 1, + sym_vec_type, + STATE(320), 1, + aux_sym_module_field_func_repeat1, + STATE(471), 1, + sym_import, + STATE(487), 1, + sym_global_type, + STATE(663), 1, + sym_export, + STATE(1097), 1, + sym__value_type, + STATE(230), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [19507] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(552), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(413), 1, + aux_sym_block_try_table_repeat1, + STATE(529), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(231), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19590] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(668), 1, + anon_sym_RPAREN, + STATE(396), 1, + aux_sym_block_block_repeat2, + STATE(495), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(232), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19673] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(256), 1, + aux_sym_block_block_repeat1, + STATE(399), 1, + aux_sym_block_block_repeat2, + STATE(501), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1297), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(233), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19756] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(638), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(314), 1, + aux_sym_block_block_repeat1, + STATE(349), 1, + aux_sym_block_block_repeat2, + STATE(510), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(234), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19839] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(634), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(405), 1, + aux_sym_block_block_repeat2, + STATE(513), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(235), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [19922] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(562), 1, + anon_sym_RPAREN, + ACTIONS(646), 1, + anon_sym_LPAREN, + STATE(416), 1, + aux_sym_module_field_func_repeat2, + STATE(534), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(236), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20005] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1456), 1, + sym__storage_type, + ACTIONS(401), 2, + anon_sym_i8, + anon_sym_i16, + STATE(237), 2, + sym__annotation, + sym_block_comment, + STATE(652), 2, + sym_packed_type, + sym__value_type, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [20062] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(628), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(246), 1, + aux_sym_block_block_repeat1, + STATE(367), 1, + aux_sym_block_block_repeat2, + STATE(522), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(238), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20145] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(596), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(300), 1, + aux_sym_block_block_repeat1, + STATE(363), 1, + aux_sym_block_block_repeat2, + STATE(502), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(239), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20228] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(636), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(263), 1, + aux_sym_block_block_repeat1, + STATE(407), 1, + aux_sym_block_block_repeat2, + STATE(475), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(240), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20311] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(636), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(407), 1, + aux_sym_block_block_repeat2, + STATE(475), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(241), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20394] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(596), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(363), 1, + aux_sym_block_block_repeat2, + STATE(502), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(242), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20477] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(399), 1, + aux_sym_block_block_repeat2, + STATE(501), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1297), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(243), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20560] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(672), 1, + anon_sym_RPAREN, + STATE(259), 1, + aux_sym_block_block_repeat1, + STATE(401), 1, + aux_sym_block_block_repeat2, + STATE(508), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(244), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20643] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(409), 1, + aux_sym_block_try_table_repeat1, + STATE(521), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(245), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20726] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(672), 1, + anon_sym_RPAREN, + STATE(401), 1, + aux_sym_block_block_repeat2, + STATE(508), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(246), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20809] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(598), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(268), 1, + aux_sym_block_block_repeat1, + STATE(411), 1, + aux_sym_block_block_repeat2, + STATE(525), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(247), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20892] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(598), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(411), 1, + aux_sym_block_block_repeat2, + STATE(525), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(248), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [20975] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(628), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(367), 1, + aux_sym_block_block_repeat2, + STATE(522), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(249), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21058] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(600), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(270), 1, + aux_sym_block_block_repeat1, + STATE(412), 1, + aux_sym_block_block_repeat2, + STATE(528), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(250), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21141] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(600), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(412), 1, + aux_sym_block_block_repeat2, + STATE(528), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(251), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21224] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(674), 1, + anon_sym_RPAREN, + STATE(424), 1, + aux_sym_block_block_repeat2, + STATE(558), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(252), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21307] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(463), 1, + aux_sym_block_block_repeat2, + STATE(660), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1371), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(253), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21390] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(604), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(313), 1, + aux_sym_block_block_repeat1, + STATE(365), 1, + aux_sym_block_block_repeat2, + STATE(512), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(254), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21473] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(457), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(414), 1, + aux_sym_block_try_table_repeat1, + STATE(532), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(255), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21556] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(432), 1, + aux_sym_block_block_repeat2, + STATE(578), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1348), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(256), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21639] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(676), 1, + anon_sym_end, + STATE(274), 1, + aux_sym_block_block_repeat1, + STATE(415), 1, + aux_sym_block_block_repeat2, + STATE(536), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(257), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21722] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(676), 1, + anon_sym_end, + STATE(415), 1, + aux_sym_block_block_repeat2, + STATE(536), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(258), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21805] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(678), 1, + anon_sym_RPAREN, + STATE(433), 1, + aux_sym_block_block_repeat2, + STATE(581), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(259), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21888] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(604), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(365), 1, + aux_sym_block_block_repeat2, + STATE(512), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(260), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [21971] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(638), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(349), 1, + aux_sym_block_block_repeat2, + STATE(510), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(261), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22054] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(680), 1, + anon_sym_end, + STATE(277), 1, + aux_sym_block_block_repeat1, + STATE(417), 1, + aux_sym_block_block_repeat2, + STATE(540), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(262), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22137] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(680), 1, + anon_sym_end, + STATE(417), 1, + aux_sym_block_block_repeat2, + STATE(540), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(263), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22220] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(646), 1, + anon_sym_LPAREN, + ACTIONS(682), 1, + anon_sym_RPAREN, + STATE(452), 1, + aux_sym_module_field_func_repeat2, + STATE(630), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(264), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22303] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(451), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(372), 1, + aux_sym_block_try_table_repeat1, + STATE(539), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(265), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22386] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(566), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(418), 1, + aux_sym_block_try_table_repeat1, + STATE(543), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(266), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22469] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(684), 1, + anon_sym_RPAREN, + STATE(280), 1, + aux_sym_block_block_repeat1, + STATE(420), 1, + aux_sym_block_block_repeat2, + STATE(547), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(267), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22552] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(684), 1, + anon_sym_RPAREN, + STATE(420), 1, + aux_sym_block_block_repeat2, + STATE(547), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(268), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22635] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(686), 1, + anon_sym_RPAREN, + STATE(281), 1, + aux_sym_block_block_repeat1, + STATE(421), 1, + aux_sym_block_block_repeat2, + STATE(550), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(269), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22718] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(686), 1, + anon_sym_RPAREN, + STATE(421), 1, + aux_sym_block_block_repeat2, + STATE(550), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(270), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22801] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(366), 1, + aux_sym_block_try_table_repeat1, + STATE(516), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(271), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22884] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(630), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(288), 1, + aux_sym_block_block_repeat1, + STATE(346), 1, + aux_sym_block_block_repeat2, + STATE(659), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(272), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [22967] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(568), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(422), 1, + aux_sym_block_try_table_repeat1, + STATE(551), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(273), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23050] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(688), 1, + anon_sym_end, + STATE(423), 1, + aux_sym_block_block_repeat2, + STATE(554), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(274), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23133] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(564), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(435), 1, + aux_sym_block_try_table_repeat1, + STATE(584), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(275), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23216] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(650), 1, + anon_sym_LPAREN, + ACTIONS(690), 1, + anon_sym_RPAREN, + STATE(450), 1, + aux_sym_block_try_table_repeat1, + STATE(624), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(276), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23299] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(692), 1, + anon_sym_end, + STATE(425), 1, + aux_sym_block_block_repeat2, + STATE(557), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(277), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23382] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(594), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(368), 1, + aux_sym_block_block_repeat2, + STATE(524), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(278), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23465] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(570), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(426), 1, + aux_sym_block_try_table_repeat1, + STATE(559), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(279), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23548] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(694), 1, + anon_sym_RPAREN, + STATE(427), 1, + aux_sym_block_block_repeat2, + STATE(562), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(280), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23631] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(696), 1, + anon_sym_RPAREN, + STATE(428), 1, + aux_sym_block_block_repeat2, + STATE(564), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(281), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23714] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(698), 1, + anon_sym_end, + STATE(303), 1, + aux_sym_block_block_repeat1, + STATE(379), 1, + aux_sym_block_block_repeat2, + STATE(592), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(282), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23797] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(572), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(429), 1, + aux_sym_block_try_table_repeat1, + STATE(565), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(283), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23880] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(620), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(208), 1, + aux_sym_block_block_repeat1, + STATE(369), 1, + aux_sym_block_block_repeat2, + STATE(533), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(284), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [23963] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(648), 1, + anon_sym_LPAREN, + ACTIONS(700), 1, + anon_sym_end, + STATE(430), 1, + aux_sym_block_try_table_repeat1, + STATE(569), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(285), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24046] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(650), 1, + anon_sym_LPAREN, + ACTIONS(702), 1, + anon_sym_RPAREN, + STATE(431), 1, + aux_sym_block_try_table_repeat1, + STATE(573), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(286), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24129] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(620), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(369), 1, + aux_sym_block_block_repeat2, + STATE(533), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(287), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24212] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(698), 1, + anon_sym_end, + STATE(379), 1, + aux_sym_block_block_repeat2, + STATE(592), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(288), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24295] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(630), 1, + anon_sym_end, + ACTIONS(640), 1, + anon_sym_LPAREN, + STATE(346), 1, + aux_sym_block_block_repeat2, + STATE(659), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(289), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24378] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(648), 1, + anon_sym_LPAREN, + ACTIONS(704), 1, + anon_sym_end, + STATE(438), 1, + aux_sym_block_try_table_repeat1, + STATE(590), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(290), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24461] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(624), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(302), 1, + aux_sym_block_block_repeat1, + STATE(338), 1, + aux_sym_block_block_repeat2, + STATE(596), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(291), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24544] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(624), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(338), 1, + aux_sym_block_block_repeat2, + STATE(596), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(292), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24627] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(443), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(371), 1, + aux_sym_block_try_table_repeat1, + STATE(542), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(293), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24710] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(626), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(305), 1, + aux_sym_block_block_repeat1, + STATE(440), 1, + aux_sym_block_block_repeat2, + STATE(600), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(294), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24793] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(626), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(440), 1, + aux_sym_block_block_repeat2, + STATE(600), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(295), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24876] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(582), 1, + anon_sym_RPAREN, + ACTIONS(646), 1, + anon_sym_LPAREN, + STATE(439), 1, + aux_sym_module_field_func_repeat2, + STATE(594), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(296), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [24959] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(536), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(406), 1, + aux_sym_block_try_table_repeat1, + STATE(515), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(297), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25042] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(706), 1, + anon_sym_end, + STATE(212), 1, + aux_sym_block_block_repeat1, + STATE(373), 1, + aux_sym_block_block_repeat2, + STATE(549), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(298), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25125] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(482), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(442), 1, + aux_sym_block_try_table_repeat1, + STATE(603), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(299), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25208] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(706), 1, + anon_sym_end, + STATE(373), 1, + aux_sym_block_block_repeat2, + STATE(549), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(300), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25291] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(708), 1, + anon_sym_RPAREN, + STATE(308), 1, + aux_sym_block_block_repeat1, + STATE(443), 1, + aux_sym_block_block_repeat2, + STATE(606), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(301), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25374] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(708), 1, + anon_sym_RPAREN, + STATE(443), 1, + aux_sym_block_block_repeat2, + STATE(606), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(302), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25457] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(710), 1, + anon_sym_end, + STATE(408), 1, + aux_sym_block_block_repeat2, + STATE(520), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(303), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25540] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(712), 1, + anon_sym_RPAREN, + STATE(309), 1, + aux_sym_block_block_repeat1, + STATE(444), 1, + aux_sym_block_block_repeat2, + STATE(609), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(304), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25623] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(712), 1, + anon_sym_RPAREN, + STATE(444), 1, + aux_sym_block_block_repeat2, + STATE(609), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(305), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25706] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(714), 1, + anon_sym_end, + STATE(226), 1, + aux_sym_block_block_repeat1, + STATE(389), 1, + aux_sym_block_block_repeat2, + STATE(654), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(306), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25789] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(584), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(445), 1, + aux_sym_block_try_table_repeat1, + STATE(611), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(307), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25872] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(716), 1, + anon_sym_RPAREN, + STATE(446), 1, + aux_sym_block_block_repeat2, + STATE(614), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(308), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [25955] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(718), 1, + anon_sym_RPAREN, + STATE(447), 1, + aux_sym_block_block_repeat2, + STATE(616), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(309), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26038] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(720), 1, + anon_sym_end, + STATE(215), 1, + aux_sym_block_block_repeat1, + STATE(374), 1, + aux_sym_block_block_repeat2, + STATE(553), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(310), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26121] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(586), 1, + anon_sym_RPAREN, + ACTIONS(650), 1, + anon_sym_LPAREN, + STATE(448), 1, + aux_sym_block_try_table_repeat1, + STATE(617), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(311), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26204] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(650), 1, + anon_sym_LPAREN, + ACTIONS(722), 1, + anon_sym_RPAREN, + STATE(449), 1, + aux_sym_block_try_table_repeat1, + STATE(621), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(312), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26287] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(720), 1, + anon_sym_end, + STATE(374), 1, + aux_sym_block_block_repeat2, + STATE(553), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(313), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26370] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(640), 1, + anon_sym_LPAREN, + ACTIONS(714), 1, + anon_sym_end, + STATE(389), 1, + aux_sym_block_block_repeat2, + STATE(654), 1, + aux_sym_block_block_repeat3, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1054), 1, + sym_param, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(314), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26453] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(318), 1, + aux_sym_block_block_repeat1, + STATE(453), 1, + aux_sym_block_block_repeat2, + STATE(633), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1354), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(315), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26536] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(453), 1, + aux_sym_block_block_repeat2, + STATE(633), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1354), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(316), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26619] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(319), 1, + aux_sym_block_block_repeat1, + STATE(454), 1, + aux_sym_block_block_repeat2, + STATE(635), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1403), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(317), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26702] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(454), 1, + aux_sym_block_block_repeat2, + STATE(635), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1403), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(318), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26785] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(455), 1, + aux_sym_block_block_repeat2, + STATE(637), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1397), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(319), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [26868] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(614), 1, + anon_sym_LPAREN, + ACTIONS(616), 1, + sym_vec_type, + STATE(466), 1, + sym_import, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(582), 1, + sym_global_type, + STATE(663), 1, + sym_export, + STATE(1097), 1, + sym__value_type, + STATE(320), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [26929] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(538), 1, + anon_sym_end, + ACTIONS(648), 1, + anon_sym_LPAREN, + STATE(375), 1, + aux_sym_block_try_table_repeat1, + STATE(555), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(321), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27012] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(325), 1, + aux_sym_block_block_repeat1, + STATE(457), 1, + aux_sym_block_block_repeat2, + STATE(645), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1312), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(322), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27095] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(457), 1, + aux_sym_block_block_repeat2, + STATE(645), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1312), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(323), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27178] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(326), 1, + aux_sym_block_block_repeat1, + STATE(458), 1, + aux_sym_block_block_repeat2, + STATE(647), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1326), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(324), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27261] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(458), 1, + aux_sym_block_block_repeat2, + STATE(647), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1326), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(325), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27344] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(459), 1, + aux_sym_block_block_repeat2, + STATE(649), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1336), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(326), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27427] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(724), 1, + anon_sym_RPAREN, + STATE(218), 1, + aux_sym_block_block_repeat1, + STATE(376), 1, + aux_sym_block_block_repeat2, + STATE(563), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(327), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27510] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(642), 1, + anon_sym_LPAREN, + ACTIONS(724), 1, + anon_sym_RPAREN, + STATE(376), 1, + aux_sym_block_block_repeat2, + STATE(563), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(328), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27593] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(332), 1, + aux_sym_block_block_repeat1, + STATE(461), 1, + aux_sym_block_block_repeat2, + STATE(655), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1355), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(329), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27676] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(461), 1, + aux_sym_block_block_repeat2, + STATE(655), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1355), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(330), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27759] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(253), 1, + aux_sym_block_block_repeat1, + STATE(462), 1, + aux_sym_block_block_repeat2, + STATE(658), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1364), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(331), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27842] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(666), 1, + anon_sym_LPAREN, + STATE(462), 1, + aux_sym_block_block_repeat2, + STATE(658), 1, + aux_sym_block_block_repeat3, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1364), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(332), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [27925] = 25, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(594), 1, + anon_sym_RPAREN, + ACTIONS(642), 1, + anon_sym_LPAREN, + STATE(328), 1, + aux_sym_block_block_repeat1, + STATE(368), 1, + aux_sym_block_block_repeat2, + STATE(524), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1085), 1, + sym_param, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(333), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28008] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(728), 1, + anon_sym_RPAREN, + ACTIONS(730), 1, + sym_identifier, + STATE(344), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(334), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28066] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(732), 1, + anon_sym_RPAREN, + ACTIONS(734), 1, + sym_identifier, + STATE(403), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(335), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28124] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(736), 1, + anon_sym_RPAREN, + ACTIONS(738), 1, + sym_identifier, + STATE(361), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(336), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28182] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(740), 1, + anon_sym_RPAREN, + ACTIONS(742), 1, + sym_identifier, + STATE(343), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(337), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28240] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(708), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(606), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(338), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28317] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(509), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1314), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(339), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28394] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(628), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(522), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(340), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28471] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(630), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(659), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(341), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28548] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(451), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(539), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(342), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28625] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(752), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(343), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28680] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(754), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(344), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28735] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(756), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(345), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [28790] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(698), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(592), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(346), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28867] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(527), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(347), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [28944] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(638), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(510), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(348), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29021] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(714), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(654), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(349), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29098] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(518), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(657), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(350), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29175] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(762), 1, + anon_sym_RPAREN, + STATE(362), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(351), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [29230] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(596), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(502), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(352), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29307] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(484), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(477), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(353), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29384] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(519), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(354), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29461] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(604), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(512), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(355), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29538] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(516), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(356), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29615] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(594), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(524), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(357), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29692] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(620), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(533), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(358), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29769] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(443), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(542), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(359), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29846] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(668), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(495), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(360), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [29923] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(764), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(361), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [29978] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(766), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(362), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [30033] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(706), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(549), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(363), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30110] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(501), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1297), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(364), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30187] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(720), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(553), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(365), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30264] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(538), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(555), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(366), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30341] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(672), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(508), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(367), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30418] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(724), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(563), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(368), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30495] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(644), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(574), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(369), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30572] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(546), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(370), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30649] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(540), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(580), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(371), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30726] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(536), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(515), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(372), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30803] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(652), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(586), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(373), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30880] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(654), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(595), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(374), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [30957] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(542), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(601), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(375), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31034] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(656), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(608), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(376), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31111] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(771), 1, + anon_sym_LPAREN, + ACTIONS(774), 1, + anon_sym_RPAREN, + ACTIONS(779), 1, + sym_vec_type, + STATE(669), 1, + sym__value_type, + STATE(518), 2, + sym_num_type, + sym_ref_type, + STATE(377), 3, + sym__annotation, + sym_block_comment, + aux_sym_local_repeat1, + ACTIONS(768), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(776), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [31164] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(658), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(613), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(378), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31241] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(710), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(520), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(379), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31318] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(592), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(615), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(380), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31395] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(782), 1, + anon_sym_end, + STATE(622), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(381), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31472] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(784), 1, + anon_sym_end, + STATE(625), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(382), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31549] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(660), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(627), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(383), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31626] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(786), 1, + anon_sym_RPAREN, + STATE(632), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(384), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31703] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(788), 1, + anon_sym_RPAREN, + STATE(634), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(385), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31780] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(662), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(636), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(386), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31857] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(760), 1, + anon_sym_LPAREN, + ACTIONS(790), 1, + anon_sym_end, + STATE(644), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(387), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [31934] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(750), 1, + anon_sym_LPAREN, + ACTIONS(792), 1, + anon_sym_RPAREN, + STATE(646), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(388), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32011] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(664), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(526), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(389), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32088] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(552), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(529), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(390), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32165] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(794), 1, + anon_sym_RPAREN, + STATE(404), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(391), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [32220] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(562), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(534), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(392), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32297] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(634), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(513), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(393), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32374] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(796), 1, + anon_sym_LPAREN, + ACTIONS(798), 1, + sym_identifier, + STATE(1097), 1, + sym__value_type, + STATE(1630), 1, + sym_global_type, + STATE(394), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [32429] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(636), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(475), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(395), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32506] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(674), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(558), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(396), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32583] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(521), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(397), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32660] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(800), 1, + anon_sym_RPAREN, + STATE(345), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(398), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [32715] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(578), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1348), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(399), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32792] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(600), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(528), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(400), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32869] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(678), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(581), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(401), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [32946] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(457), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(532), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(402), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33023] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(802), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(403), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [33078] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(405), 1, + sym_vec_type, + ACTIONS(726), 1, + anon_sym_LPAREN, + ACTIONS(804), 1, + anon_sym_RPAREN, + STATE(377), 1, + aux_sym_local_repeat1, + STATE(669), 1, + sym__value_type, + STATE(404), 2, + sym__annotation, + sym_block_comment, + STATE(518), 2, + sym_num_type, + sym_ref_type, + ACTIONS(395), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(403), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [33133] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(676), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(536), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(405), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33210] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(564), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(584), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(406), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33287] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(680), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(540), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(407), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33364] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(806), 1, + anon_sym_end, + STATE(588), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(408), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33441] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(566), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(543), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(409), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33518] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(808), 1, + anon_sym_end, + STATE(589), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(410), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33595] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(684), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(547), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(411), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33672] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(686), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(550), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(412), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33749] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(704), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(590), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(413), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33826] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(568), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(551), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(414), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33903] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(688), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(554), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(415), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [33980] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(582), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(594), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(416), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34057] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(692), 1, + anon_sym_end, + ACTIONS(748), 1, + anon_sym_LPAREN, + STATE(557), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(417), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34134] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(570), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(559), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(418), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34211] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(812), 1, + anon_sym_LPAREN, + ACTIONS(814), 1, + sym_identifier, + ACTIONS(816), 1, + sym_uinteger, + STATE(473), 1, + aux_sym_module_field_func_repeat1, + STATE(514), 1, + sym_table_type, + STATE(663), 1, + sym_export, + STATE(666), 1, + sym_import, + STATE(1419), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(419), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [34272] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(694), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(562), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(420), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34349] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(696), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(564), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(421), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34426] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(572), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(565), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(422), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34503] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(818), 1, + anon_sym_end, + STATE(567), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(423), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34580] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(820), 1, + anon_sym_RPAREN, + STATE(602), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(424), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34657] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(748), 1, + anon_sym_LPAREN, + ACTIONS(822), 1, + anon_sym_end, + STATE(568), 1, + aux_sym_block_block_repeat3, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1079), 1, + sym_result, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(425), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34734] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(700), 1, + anon_sym_end, + ACTIONS(760), 1, + anon_sym_LPAREN, + STATE(569), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(426), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34811] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(824), 1, + anon_sym_RPAREN, + STATE(571), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(427), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34888] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(826), 1, + anon_sym_RPAREN, + STATE(572), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(428), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [34965] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(702), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(573), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(429), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35042] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(760), 1, + anon_sym_LPAREN, + ACTIONS(828), 1, + anon_sym_end, + STATE(662), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(430), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35119] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(750), 1, + anon_sym_LPAREN, + ACTIONS(830), 1, + anon_sym_RPAREN, + STATE(576), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(431), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35196] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(607), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1379), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(432), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35273] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(832), 1, + anon_sym_RPAREN, + STATE(610), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(433), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35350] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(624), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(596), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(434), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35427] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(690), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(624), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(435), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35504] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(626), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(600), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(436), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35581] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(482), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(603), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(437), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35658] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(760), 1, + anon_sym_LPAREN, + ACTIONS(834), 1, + anon_sym_end, + STATE(626), 1, + aux_sym_block_block_repeat3, + STATE(812), 1, + aux_sym_block_try_table_repeat1, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1082), 1, + sym_catch, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(438), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35735] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(682), 1, + anon_sym_RPAREN, + ACTIONS(758), 1, + anon_sym_LPAREN, + STATE(630), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(439), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35812] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(712), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(609), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(440), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35889] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(606), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(494), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(441), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [35966] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(584), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(611), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(442), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36043] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(716), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(614), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(443), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36120] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(718), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(616), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(444), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36197] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(586), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(617), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(445), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36274] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(836), 1, + anon_sym_RPAREN, + STATE(619), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(446), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36351] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(744), 1, + anon_sym_LPAREN, + ACTIONS(838), 1, + anon_sym_RPAREN, + STATE(620), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(447), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36428] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(722), 1, + anon_sym_RPAREN, + ACTIONS(750), 1, + anon_sym_LPAREN, + STATE(621), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(448), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36505] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(750), 1, + anon_sym_LPAREN, + ACTIONS(840), 1, + anon_sym_RPAREN, + STATE(623), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(449), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36582] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(750), 1, + anon_sym_LPAREN, + ACTIONS(842), 1, + anon_sym_RPAREN, + STATE(639), 1, + aux_sym_block_block_repeat3, + STATE(797), 1, + aux_sym_block_try_table_repeat1, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1101), 1, + sym_catch, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(450), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36659] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(633), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1354), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(451), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36736] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(758), 1, + anon_sym_LPAREN, + ACTIONS(844), 1, + anon_sym_RPAREN, + STATE(643), 1, + aux_sym_block_block_repeat3, + STATE(836), 1, + aux_sym_module_field_func_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1084), 1, + sym_local, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(452), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36813] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(635), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1403), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(453), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36890] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(637), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1397), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(454), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [36967] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(638), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1307), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(455), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37044] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(645), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1312), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(456), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37121] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(647), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1326), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(457), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37198] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(649), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1336), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(458), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37275] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(650), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1342), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(459), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37352] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(655), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1355), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(460), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37429] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(658), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1364), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(461), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37506] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(660), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1371), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(462), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37583] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(746), 1, + anon_sym_LPAREN, + STATE(661), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + STATE(1373), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(463), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37660] = 23, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(598), 1, + anon_sym_RPAREN, + ACTIONS(744), 1, + anon_sym_LPAREN, + STATE(525), 1, + aux_sym_block_block_repeat3, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1089), 1, + sym_result, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(464), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37737] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(345), 1, + anon_sym_block, + ACTIONS(349), 1, + anon_sym_if, + ACTIONS(353), 1, + anon_sym_loop, + ACTIONS(355), 1, + anon_sym_try_table, + ACTIONS(361), 1, + sym_instr_name, + ACTIONS(846), 1, + anon_sym_LPAREN, + STATE(470), 1, + aux_sym_block_block_repeat3, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + ACTIONS(357), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(848), 2, + anon_sym_end, + anon_sym_else, + STATE(465), 2, + sym__annotation, + sym_block_comment, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [37809] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(796), 1, + anon_sym_LPAREN, + STATE(483), 1, + sym_global_type, + STATE(1097), 1, + sym__value_type, + STATE(466), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [37861] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(796), 1, + anon_sym_LPAREN, + STATE(487), 1, + sym_global_type, + STATE(1097), 1, + sym__value_type, + STATE(467), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [37913] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(796), 1, + anon_sym_LPAREN, + STATE(1097), 1, + sym__value_type, + STATE(1526), 1, + sym_global_type, + STATE(468), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [37965] = 22, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(852), 1, + anon_sym_end, + ACTIONS(854), 1, + sym_identifier, + STATE(488), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(469), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38039] = 20, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(856), 1, + anon_sym_LPAREN, + ACTIONS(859), 1, + anon_sym_block, + ACTIONS(864), 1, + anon_sym_if, + ACTIONS(867), 1, + anon_sym_loop, + ACTIONS(870), 1, + anon_sym_try_table, + ACTIONS(876), 1, + sym_instr_name, + STATE(865), 1, + sym__block_block_folded, + STATE(866), 1, + sym__block_if_folded, + STATE(867), 1, + sym__block_loop_folded, + STATE(868), 1, + sym__block_try_table_folded, + STATE(869), 1, + sym__call_indirect_folded, + STATE(870), 1, + sym__instr, + STATE(872), 1, + sym__plain_instr_folded, + ACTIONS(862), 2, + anon_sym_end, + anon_sym_else, + ACTIONS(873), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(470), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat3, + STATE(864), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38109] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(796), 1, + anon_sym_LPAREN, + STATE(582), 1, + sym_global_type, + STATE(1097), 1, + sym__value_type, + STATE(471), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [38161] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(812), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(474), 1, + aux_sym_module_field_func_repeat1, + STATE(511), 1, + sym_table_type, + STATE(663), 1, + sym_export, + STATE(665), 1, + sym_import, + STATE(1436), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(472), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [38219] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(812), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(511), 1, + sym_table_type, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(663), 1, + sym_export, + STATE(665), 1, + sym_import, + STATE(1436), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(473), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [38277] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(812), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(593), 1, + sym_table_type, + STATE(663), 1, + sym_export, + STATE(664), 1, + sym_import, + STATE(1439), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(474), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [38335] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(680), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(475), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38406] = 20, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(879), 1, + anon_sym_LPAREN, + ACTIONS(882), 1, + anon_sym_RPAREN, + ACTIONS(884), 1, + anon_sym_block, + ACTIONS(887), 1, + anon_sym_if, + ACTIONS(890), 1, + anon_sym_loop, + ACTIONS(893), 1, + anon_sym_try_table, + ACTIONS(899), 1, + sym_instr_name, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(896), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(476), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat3, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38475] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(562), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(477), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38546] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(906), 1, + anon_sym_LPAREN, + STATE(478), 2, + sym__annotation, + sym_block_comment, + ACTIONS(904), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [38587] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(443), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(479), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38658] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(634), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(480), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38729] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1614), 1, + sym__value_type, + STATE(481), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [38778] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(908), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(482), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38849] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(908), 1, + anon_sym_RPAREN, + STATE(538), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(483), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38920] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(910), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(484), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [38991] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(910), 1, + anon_sym_RPAREN, + STATE(541), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(485), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39062] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(912), 1, + anon_sym_end, + STATE(599), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(486), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39133] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(914), 1, + anon_sym_RPAREN, + STATE(577), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(487), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39204] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(912), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(488), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39275] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(636), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(489), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39346] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1314), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(490), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39417] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(918), 1, + anon_sym_RPAREN, + STATE(505), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(491), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39488] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(331), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(492), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39559] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(455), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(493), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39630] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(668), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(494), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39701] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(674), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(495), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39772] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(920), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(496), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39843] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(922), 1, + anon_sym_RPAREN, + STATE(496), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(497), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39914] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(598), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(498), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [39985] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(914), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(499), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40056] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(628), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(500), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40127] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1348), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(501), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40198] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(706), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(502), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40269] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(600), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(503), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40340] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(924), 1, + anon_sym_RPAREN, + STATE(579), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(504), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40411] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(926), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(505), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40482] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(457), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(506), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40553] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(322), 1, + anon_sym_func, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(928), 1, + anon_sym_RPAREN, + STATE(805), 1, + sym_ref_type, + STATE(1241), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1566), 1, + sym_elem_list, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(507), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [40608] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(678), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(508), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40679] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1297), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(509), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40750] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(714), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(510), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40821] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(930), 1, + anon_sym_RPAREN, + STATE(612), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(511), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40892] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(720), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(512), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [40963] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(676), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(513), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41034] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(932), 1, + anon_sym_RPAREN, + STATE(531), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(514), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41105] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(564), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(515), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41176] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(538), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(516), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41247] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(638), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(517), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41318] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(936), 1, + anon_sym_LPAREN, + STATE(518), 2, + sym__annotation, + sym_block_comment, + ACTIONS(934), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [41359] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(518), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(519), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41430] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(806), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(520), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41501] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(566), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(521), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41572] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(672), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(522), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41643] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(275), 1, + anon_sym_LPAREN, + STATE(523), 2, + sym__annotation, + sym_block_comment, + ACTIONS(277), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [41684] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(724), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(524), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41755] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(684), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(525), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41826] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(808), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(526), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41897] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(333), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(527), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [41968] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(686), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(528), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42039] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(704), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(529), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42110] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(938), 1, + anon_sym_RPAREN, + STATE(560), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(530), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42181] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(930), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(531), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42252] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(568), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(532), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42323] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(644), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(533), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42394] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(582), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(534), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42465] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1583), 1, + sym__value_type, + STATE(535), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [42514] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(688), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(536), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42585] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(596), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(537), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42656] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(940), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(538), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42727] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(536), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(539), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42798] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(692), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(540), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42869] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(942), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(541), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [42940] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(540), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(542), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43011] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(570), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(543), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43082] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(944), 1, + anon_sym_RPAREN, + STATE(499), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(544), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43153] = 20, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(862), 1, + anon_sym_end, + ACTIONS(946), 1, + anon_sym_LPAREN, + ACTIONS(949), 1, + anon_sym_block, + ACTIONS(952), 1, + anon_sym_if, + ACTIONS(955), 1, + anon_sym_loop, + ACTIONS(958), 1, + anon_sym_try_table, + ACTIONS(964), 1, + sym_instr_name, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(961), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(545), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat3, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43222] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(484), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(546), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43293] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(694), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(547), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43364] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(969), 1, + anon_sym_LPAREN, + STATE(548), 2, + sym__annotation, + sym_block_comment, + ACTIONS(967), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [43405] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(652), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(549), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43476] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(696), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(550), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43547] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(572), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(551), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43618] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1589), 1, + sym__value_type, + STATE(552), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [43667] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(654), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(553), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43738] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(818), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(554), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43809] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(542), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(555), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43880] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(453), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(556), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [43951] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(822), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(557), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44022] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(820), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(558), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44093] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(700), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(559), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44164] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(971), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(560), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44235] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(630), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(561), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44306] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(824), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(562), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44377] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(656), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(563), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44448] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(826), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(564), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44519] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(702), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(565), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44590] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(975), 1, + anon_sym_LPAREN, + STATE(663), 1, + sym_export, + STATE(566), 3, + sym__annotation, + sym_block_comment, + aux_sym_module_field_func_repeat1, + ACTIONS(973), 20, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + sym_uinteger, + [44633] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(978), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(567), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44704] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(980), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(568), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44775] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(828), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(569), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44846] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(604), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(570), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44917] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(982), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(571), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [44988] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(984), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(572), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45059] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(830), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(573), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45130] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(658), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(574), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45201] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(620), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(575), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45272] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(986), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(576), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45343] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(988), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(577), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45414] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1379), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(578), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45485] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(990), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(579), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45556] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(592), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(580), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45627] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(832), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(581), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45698] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(988), 1, + anon_sym_RPAREN, + STATE(482), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(582), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45769] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(624), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(583), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45840] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(690), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(584), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [45911] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(279), 1, + anon_sym_LPAREN, + STATE(585), 2, + sym__annotation, + sym_block_comment, + ACTIONS(281), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [45952] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(782), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(586), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46023] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(626), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(587), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46094] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(992), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(588), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46165] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(994), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(589), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46236] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(834), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(590), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46307] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(482), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(591), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46378] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(710), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(592), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46449] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(996), 1, + anon_sym_RPAREN, + STATE(484), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(593), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46520] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(682), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(594), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46591] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(784), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(595), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46662] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(708), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(596), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46733] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(322), 1, + anon_sym_func, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(998), 1, + anon_sym_RPAREN, + STATE(805), 1, + sym_ref_type, + STATE(1241), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1609), 1, + sym_elem_list, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(597), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [46788] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1002), 1, + anon_sym_LPAREN, + STATE(598), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1000), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [46829] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1004), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(599), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46900] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(712), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(600), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [46971] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(660), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(601), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47042] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1006), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(602), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47113] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(584), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(603), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47184] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(441), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(604), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47255] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(283), 1, + anon_sym_LPAREN, + STATE(605), 2, + sym__annotation, + sym_block_comment, + ACTIONS(285), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [47296] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(716), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(606), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47367] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1400), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(607), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47438] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(786), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(608), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47509] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(718), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(609), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47580] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1008), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(610), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47651] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(586), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(611), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47722] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(996), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(612), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47793] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(788), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(613), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47864] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(836), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(614), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [47935] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(662), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(615), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48006] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(838), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(616), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48077] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(722), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(617), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48148] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(451), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(618), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48219] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1010), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(619), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48290] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1012), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(620), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48361] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(840), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(621), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48432] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1014), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(622), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48503] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1016), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(623), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48574] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(842), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(624), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48645] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1018), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(625), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48716] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1020), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(626), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48787] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(790), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(627), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48858] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1354), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(628), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [48929] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1557), 1, + sym__value_type, + STATE(629), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [48978] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(844), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(630), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49049] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(594), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(631), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49120] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1022), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(632), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49191] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1403), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(633), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49262] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1024), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(634), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49333] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1397), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(635), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49404] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(792), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(636), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49475] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1307), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(637), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49546] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1320), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(638), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49617] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1026), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(639), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49688] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1030), 1, + anon_sym_LPAREN, + STATE(640), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1028), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [49729] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1312), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(641), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49800] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(616), 1, + sym_vec_type, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1521), 1, + sym__value_type, + STATE(642), 2, + sym__annotation, + sym_block_comment, + STATE(1095), 2, + sym_num_type, + sym_ref_type, + ACTIONS(612), 4, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [49849] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1032), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(643), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49920] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1034), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(644), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [49991] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1326), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(645), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50062] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(902), 1, + anon_sym_LPAREN, + ACTIONS(1036), 1, + anon_sym_RPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(646), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50133] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1336), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(647), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50204] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(322), 1, + anon_sym_func, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(1038), 1, + anon_sym_RPAREN, + STATE(805), 1, + sym_ref_type, + STATE(1241), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1561), 1, + sym_elem_list, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(648), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [50259] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1342), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(649), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50330] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1344), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(650), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50401] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(606), 1, + anon_sym_RPAREN, + ACTIONS(902), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(651), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50472] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1042), 1, + anon_sym_LPAREN, + STATE(652), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1040), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [50513] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1355), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(653), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50584] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(664), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(654), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50655] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1364), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(655), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50726] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1046), 1, + anon_sym_LPAREN, + STATE(656), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1044), 22, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_i8, + anon_sym_i16, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [50767] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(552), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(657), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50838] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1371), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(658), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50909] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(698), 1, + anon_sym_end, + ACTIONS(850), 1, + anon_sym_LPAREN, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(659), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [50980] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1373), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(660), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [51051] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(303), 1, + anon_sym_block, + ACTIONS(305), 1, + anon_sym_if, + ACTIONS(307), 1, + anon_sym_loop, + ACTIONS(309), 1, + anon_sym_try_table, + ACTIONS(315), 1, + sym_instr_name, + ACTIONS(916), 1, + anon_sym_LPAREN, + STATE(476), 1, + aux_sym_block_block_repeat3, + STATE(1070), 1, + sym__block_block_folded, + STATE(1071), 1, + sym__block_if_folded, + STATE(1072), 1, + sym__block_loop_folded, + STATE(1074), 1, + sym__block_try_table_folded, + STATE(1076), 1, + sym__call_indirect_folded, + STATE(1083), 1, + sym__instr, + STATE(1086), 1, + sym__plain_instr_folded, + STATE(1376), 1, + sym__block_if_then_folded, + ACTIONS(311), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(661), 2, + sym__annotation, + sym_block_comment, + STATE(1068), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [51122] = 21, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(373), 1, + anon_sym_block, + ACTIONS(377), 1, + anon_sym_if, + ACTIONS(379), 1, + anon_sym_loop, + ACTIONS(381), 1, + anon_sym_try_table, + ACTIONS(387), 1, + sym_instr_name, + ACTIONS(850), 1, + anon_sym_LPAREN, + ACTIONS(1048), 1, + anon_sym_end, + STATE(545), 1, + aux_sym_block_block_repeat3, + STATE(1043), 1, + sym__block_try_table_folded, + STATE(1052), 1, + sym__call_indirect_folded, + STATE(1053), 1, + sym__instr, + STATE(1055), 1, + sym__plain_instr_folded, + STATE(1130), 1, + sym__block_block_folded, + STATE(1151), 1, + sym__block_if_folded, + STATE(1162), 1, + sym__block_loop_folded, + ACTIONS(383), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(662), 2, + sym__annotation, + sym_block_comment, + STATE(1160), 6, + sym_block_block, + sym_block_if, + sym_block_loop, + sym_block_try_table, + sym__call_indirect, + sym_plain_instr, + [51193] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1052), 1, + anon_sym_LPAREN, + STATE(663), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1050), 20, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + sym_uinteger, + [51232] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(485), 1, + sym_table_type, + STATE(1417), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(664), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [51281] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(593), 1, + sym_table_type, + STATE(1439), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(665), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [51330] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(816), 1, + sym_uinteger, + STATE(511), 1, + sym_table_type, + STATE(1436), 1, + sym_ref_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(666), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [51379] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1056), 1, + anon_sym_LPAREN, + STATE(667), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1054), 20, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + sym_uinteger, + [51418] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1060), 1, + anon_sym_LPAREN, + STATE(668), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1058), 20, + anon_sym_i32, + anon_sym_i64, + anon_sym_f32, + anon_sym_f64, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + sym_uinteger, + [51457] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1064), 1, + anon_sym_LPAREN, + STATE(669), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1062), 20, + anon_sym_i32, + anon_sym_i64, + anon_sym_RPAREN, + anon_sym_f32, + anon_sym_f64, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_vec_type, + [51496] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1066), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(670), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1068), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51534] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1070), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(671), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1072), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51572] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1074), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(672), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1076), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51610] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1078), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(673), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1080), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51648] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1082), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(674), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1084), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51686] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1086), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(675), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1088), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51724] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1090), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(676), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1092), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51762] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1094), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(677), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1096), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51800] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1098), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(678), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1100), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51838] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1102), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(679), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1104), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51876] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1106), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(680), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1108), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51914] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1110), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(681), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1112), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51952] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1114), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(682), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1116), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [51990] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1118), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(683), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1120), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52028] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1122), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(684), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1124), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52066] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1126), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(685), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1128), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52104] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1130), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(686), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1132), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52142] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1134), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(687), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1136), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52180] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1138), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(688), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1140), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52218] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1142), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(689), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1144), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52256] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1146), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(690), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1148), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52294] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1150), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(691), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1152), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52332] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1154), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(692), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1156), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52370] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1158), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(693), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1160), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52408] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1162), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(694), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1164), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52446] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1166), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(695), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1168), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52484] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1170), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(696), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1172), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52522] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1174), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(697), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1176), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52560] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1178), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(698), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1180), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52598] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1182), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(699), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1184), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52636] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1186), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(700), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1188), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52674] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1190), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(701), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1192), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52712] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1194), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(702), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1196), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52750] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1198), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(703), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1200), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52788] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1202), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(704), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1204), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52826] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1206), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(705), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1208), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52864] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1210), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(706), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1212), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52902] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1214), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(707), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1216), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52940] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1218), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(708), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1220), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [52978] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1222), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(709), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1224), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [53016] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1226), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(710), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1228), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [53054] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1230), 2, + anon_sym_LPAREN, + anon_sym_func, + STATE(711), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1232), 18, + anon_sym_RPAREN, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + sym_identifier, + sym_string, + sym_uinteger, + [53092] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1236), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1622), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(712), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53135] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1238), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1507), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(713), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53178] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1240), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1491), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(714), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53221] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1242), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1605), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(715), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53264] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1244), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1546), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(716), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53307] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1246), 1, + anon_sym_null, + STATE(51), 1, + sym_index, + STATE(1548), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(717), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53350] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1549), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(718), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53390] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1555), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(719), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53430] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1524), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(720), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53470] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1510), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(721), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53510] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1519), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(722), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53550] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(51), 1, + sym_index, + STATE(1635), 1, + sym_heap_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(723), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1234), 14, + anon_sym_array, + anon_sym_cont, + anon_sym_func, + anon_sym_any, + anon_sym_eq, + anon_sym_i31, + anon_sym_struct, + anon_sym_none, + anon_sym_nofunc, + anon_sym_exn, + anon_sym_noexn, + anon_sym_extern, + anon_sym_noextern, + anon_sym_nocont, + [53590] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1250), 1, + anon_sym_LPAREN, + STATE(1384), 1, + sym__module_field, + ACTIONS(1248), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(724), 3, + sym__annotation, + sym_block_comment, + aux_sym_root_repeat2, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53629] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(1253), 1, + sym_uinteger, + STATE(1127), 1, + sym_ref_type, + STATE(725), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [53668] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + ACTIONS(1255), 1, + sym_uinteger, + STATE(1075), 1, + sym_ref_type, + STATE(726), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [53707] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1257), 1, + anon_sym_LPAREN, + ACTIONS(1259), 1, + anon_sym_RPAREN, + ACTIONS(1261), 1, + sym_identifier, + STATE(732), 1, + aux_sym_root_repeat2, + STATE(1384), 1, + sym__module_field, + STATE(727), 2, + sym__annotation, + sym_block_comment, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53750] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1128), 1, + sym_ref_type, + STATE(728), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [53786] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1257), 1, + anon_sym_LPAREN, + ACTIONS(1263), 1, + anon_sym_RPAREN, + STATE(724), 1, + aux_sym_root_repeat2, + STATE(1384), 1, + sym__module_field, + STATE(729), 2, + sym__annotation, + sym_block_comment, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53826] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1257), 1, + anon_sym_LPAREN, + ACTIONS(1265), 1, + ts_builtin_sym_end, + STATE(724), 1, + aux_sym_root_repeat2, + STATE(1384), 1, + sym__module_field, + STATE(730), 2, + sym__annotation, + sym_block_comment, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53866] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(670), 1, + anon_sym_LPAREN, + STATE(1073), 1, + sym_ref_type, + STATE(731), 2, + sym__annotation, + sym_block_comment, + ACTIONS(326), 14, + anon_sym_anyref, + anon_sym_eqref, + anon_sym_i31ref, + anon_sym_structref, + anon_sym_arrayref, + anon_sym_nullref, + anon_sym_funcref, + anon_sym_nullfuncref, + anon_sym_exnref, + anon_sym_nullexnref, + anon_sym_externref, + anon_sym_nullexternref, + anon_sym_contref, + anon_sym_nullcontref, + [53902] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1257), 1, + anon_sym_LPAREN, + ACTIONS(1267), 1, + anon_sym_RPAREN, + STATE(724), 1, + aux_sym_root_repeat2, + STATE(1384), 1, + sym__module_field, + STATE(732), 2, + sym__annotation, + sym_block_comment, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53942] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1257), 1, + anon_sym_LPAREN, + ACTIONS(1267), 1, + anon_sym_RPAREN, + STATE(729), 1, + aux_sym_root_repeat2, + STATE(1384), 1, + sym__module_field, + STATE(733), 2, + sym__annotation, + sym_block_comment, + STATE(1352), 12, + sym_module_field_data, + sym_module_field_elem, + sym_module_field_export, + sym_module_field_func, + sym_module_field_global, + sym_module_field_import, + sym_module_field_memory, + sym_module_field_start, + sym_module_field_table, + sym_module_field_tag, + sym_rec_type, + sym_type_def, + [53982] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1269), 1, + anon_sym_LPAREN, + ACTIONS(1271), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(740), 1, + aux_sym_block_block_repeat1, + STATE(752), 1, + sym_type_use, + STATE(777), 1, + aux_sym_block_block_repeat2, + STATE(989), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(734), 2, + sym__annotation, + sym_block_comment, + [54039] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1269), 1, + anon_sym_LPAREN, + ACTIONS(1273), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(747), 1, + aux_sym_block_block_repeat1, + STATE(757), 1, + sym_type_use, + STATE(790), 1, + aux_sym_block_block_repeat2, + STATE(1001), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(735), 2, + sym__annotation, + sym_block_comment, + [54096] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1275), 1, + anon_sym_LPAREN, + STATE(743), 1, + sym_type_use, + STATE(746), 1, + aux_sym_block_block_repeat1, + STATE(781), 1, + aux_sym_block_block_repeat2, + STATE(871), 1, + sym_param, + STATE(873), 1, + sym_result, + STATE(736), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54139] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1269), 1, + anon_sym_LPAREN, + ACTIONS(1280), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(749), 1, + aux_sym_block_block_repeat1, + STATE(751), 1, + sym_type_use, + STATE(779), 1, + aux_sym_block_block_repeat2, + STATE(953), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(737), 2, + sym__annotation, + sym_block_comment, + [54196] = 18, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1269), 1, + anon_sym_LPAREN, + ACTIONS(1282), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(754), 1, + aux_sym_block_block_repeat1, + STATE(758), 1, + sym_type_use, + STATE(791), 1, + aux_sym_block_block_repeat2, + STATE(976), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(738), 2, + sym__annotation, + sym_block_comment, + [54253] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1284), 1, + anon_sym_LPAREN, + ACTIONS(1286), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(838), 1, + aux_sym_elem_repeat2, + STATE(1235), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1418), 1, + sym__instr_folded, + STATE(1420), 1, + sym_elem_expr, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(739), 2, + sym__annotation, + sym_block_comment, + [54308] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1290), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(780), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(995), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(740), 2, + sym__annotation, + sym_block_comment, + [54362] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1292), 1, + anon_sym_LPAREN, + STATE(786), 1, + aux_sym_block_block_repeat2, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(871), 1, + sym_param, + STATE(873), 1, + sym_result, + STATE(741), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54402] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1297), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(771), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(966), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(742), 2, + sym__annotation, + sym_block_comment, + [54456] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1299), 1, + anon_sym_LPAREN, + STATE(741), 1, + aux_sym_block_block_repeat1, + STATE(789), 1, + aux_sym_block_block_repeat2, + STATE(871), 1, + sym_param, + STATE(873), 1, + sym_result, + STATE(743), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54496] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1304), 1, + anon_sym_LPAREN, + ACTIONS(1307), 1, + anon_sym_RPAREN, + STATE(766), 1, + aux_sym_block_block_repeat1, + STATE(769), 1, + sym_type_use, + STATE(831), 1, + aux_sym_block_block_repeat2, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(744), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54540] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1309), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(774), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(998), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(745), 2, + sym__annotation, + sym_block_comment, + [54594] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1299), 1, + anon_sym_LPAREN, + STATE(787), 1, + aux_sym_block_block_repeat1, + STATE(789), 1, + aux_sym_block_block_repeat2, + STATE(871), 1, + sym_param, + STATE(873), 1, + sym_result, + STATE(746), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54634] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1311), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(784), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(957), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(747), 2, + sym__annotation, + sym_block_comment, + [54688] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1313), 1, + anon_sym_LPAREN, + STATE(761), 1, + sym_type_use, + STATE(763), 1, + aux_sym_block_block_repeat1, + STATE(794), 1, + aux_sym_block_block_repeat2, + STATE(1054), 1, + sym_param, + STATE(1079), 1, + sym_result, + STATE(748), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [54730] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1316), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(772), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(960), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(749), 2, + sym__annotation, + sym_block_comment, + [54784] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1318), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(785), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(978), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(750), 2, + sym__annotation, + sym_block_comment, + [54838] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1316), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(742), 1, + aux_sym_block_block_repeat1, + STATE(772), 1, + aux_sym_block_block_repeat2, + STATE(960), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(751), 2, + sym__annotation, + sym_block_comment, + [54892] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1290), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(745), 1, + aux_sym_block_block_repeat1, + STATE(780), 1, + aux_sym_block_block_repeat2, + STATE(995), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(752), 2, + sym__annotation, + sym_block_comment, + [54946] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1320), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(792), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(986), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(753), 2, + sym__annotation, + sym_block_comment, + [55000] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1322), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(783), 1, + aux_sym_block_block_repeat2, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(981), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(754), 2, + sym__annotation, + sym_block_comment, + [55054] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1338), 1, + anon_sym_param, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1342), 1, + anon_sym_type, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1334), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1336), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(755), 2, + sym__annotation, + sym_block_comment, + [55104] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1346), 1, + anon_sym_LPAREN, + ACTIONS(1348), 1, + anon_sym_RPAREN, + ACTIONS(1350), 1, + sym_identifier, + ACTIONS(1352), 1, + sym_string, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(775), 1, + sym_mem_use, + STATE(1359), 1, + sym_offset, + STATE(1362), 1, + aux_sym_data_repeat1, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(756), 2, + sym__annotation, + sym_block_comment, + [55158] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1311), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(750), 1, + aux_sym_block_block_repeat1, + STATE(784), 1, + aux_sym_block_block_repeat2, + STATE(957), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(757), 2, + sym__annotation, + sym_block_comment, + [55212] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1288), 1, + anon_sym_LPAREN, + ACTIONS(1322), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(753), 1, + aux_sym_block_block_repeat1, + STATE(783), 1, + aux_sym_block_block_repeat2, + STATE(981), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(758), 2, + sym__annotation, + sym_block_comment, + [55266] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1364), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1366), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(759), 2, + sym__annotation, + sym_block_comment, + [55316] = 17, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1376), 1, + anon_sym_data, + ACTIONS(1378), 1, + anon_sym_elem, + ACTIONS(1380), 1, + anon_sym_func, + ACTIONS(1382), 1, + anon_sym_export, + ACTIONS(1384), 1, + anon_sym_global, + ACTIONS(1386), 1, + anon_sym_table, + ACTIONS(1388), 1, + anon_sym_memory, + ACTIONS(1390), 1, + anon_sym_tag, + ACTIONS(1392), 1, + anon_sym_import, + ACTIONS(1394), 1, + anon_sym_module, + ACTIONS(1396), 1, + anon_sym_start, + ACTIONS(1398), 1, + anon_sym_rec, + ACTIONS(1400), 1, + anon_sym_type, + STATE(760), 2, + sym__annotation, + sym_block_comment, + [55369] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1402), 1, + anon_sym_LPAREN, + STATE(764), 1, + aux_sym_block_block_repeat1, + STATE(798), 1, + aux_sym_block_block_repeat2, + STATE(1054), 1, + sym_param, + STATE(1079), 1, + sym_result, + STATE(761), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55408] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1338), 1, + anon_sym_param, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1334), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1336), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(762), 2, + sym__annotation, + sym_block_comment, + [55455] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1402), 1, + anon_sym_LPAREN, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(798), 1, + aux_sym_block_block_repeat2, + STATE(1054), 1, + sym_param, + STATE(1079), 1, + sym_result, + STATE(763), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55494] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1405), 1, + anon_sym_LPAREN, + STATE(795), 1, + aux_sym_block_block_repeat1, + STATE(799), 1, + aux_sym_block_block_repeat2, + STATE(1054), 1, + sym_param, + STATE(1079), 1, + sym_result, + STATE(764), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55533] = 16, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1408), 1, + anon_sym_export, + ACTIONS(1410), 1, + anon_sym_import, + ACTIONS(1412), 1, + anon_sym_local, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(765), 2, + sym__annotation, + sym_block_comment, + [55584] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1414), 1, + anon_sym_LPAREN, + ACTIONS(1417), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(842), 1, + aux_sym_block_block_repeat2, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(766), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55625] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1419), 1, + anon_sym_LPAREN, + ACTIONS(1422), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(837), 1, + aux_sym_block_block_repeat2, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(767), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55666] = 16, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1346), 1, + anon_sym_LPAREN, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1424), 1, + anon_sym_RPAREN, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(776), 1, + sym_mem_use, + STATE(1395), 1, + sym_offset, + STATE(1401), 1, + aux_sym_data_repeat1, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(768), 2, + sym__annotation, + sym_block_comment, + [55717] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1414), 1, + anon_sym_LPAREN, + ACTIONS(1417), 1, + anon_sym_RPAREN, + STATE(767), 1, + aux_sym_block_block_repeat1, + STATE(842), 1, + aux_sym_block_block_repeat2, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(769), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [55758] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1364), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1366), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(770), 2, + sym__annotation, + sym_block_comment, + [55805] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1426), 1, + anon_sym_LPAREN, + ACTIONS(1428), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(970), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(771), 2, + sym__annotation, + sym_block_comment, + [55853] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1297), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(966), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(772), 2, + sym__annotation, + sym_block_comment, + [55901] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1364), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1366), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(773), 2, + sym__annotation, + sym_block_comment, + [55945] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1426), 1, + anon_sym_LPAREN, + ACTIONS(1430), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(999), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(774), 2, + sym__annotation, + sym_block_comment, + [55993] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1424), 1, + anon_sym_RPAREN, + ACTIONS(1432), 1, + anon_sym_LPAREN, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(1395), 1, + sym_offset, + STATE(1401), 1, + aux_sym_data_repeat1, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(775), 2, + sym__annotation, + sym_block_comment, + [56041] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1432), 1, + anon_sym_LPAREN, + ACTIONS(1434), 1, + anon_sym_RPAREN, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(1389), 1, + sym_offset, + STATE(1393), 1, + aux_sym_data_repeat1, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(776), 2, + sym__annotation, + sym_block_comment, + [56089] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1290), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(995), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(777), 2, + sym__annotation, + sym_block_comment, + [56137] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1334), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1336), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(778), 2, + sym__annotation, + sym_block_comment, + [56181] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1316), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(960), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(779), 2, + sym__annotation, + sym_block_comment, + [56229] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1309), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(998), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(780), 2, + sym__annotation, + sym_block_comment, + [56277] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1436), 1, + anon_sym_LPAREN, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(873), 1, + sym_result, + STATE(781), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56311] = 16, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1376), 1, + anon_sym_data, + ACTIONS(1378), 1, + anon_sym_elem, + ACTIONS(1380), 1, + anon_sym_func, + ACTIONS(1382), 1, + anon_sym_export, + ACTIONS(1384), 1, + anon_sym_global, + ACTIONS(1386), 1, + anon_sym_table, + ACTIONS(1388), 1, + anon_sym_memory, + ACTIONS(1390), 1, + anon_sym_tag, + ACTIONS(1392), 1, + anon_sym_import, + ACTIONS(1396), 1, + anon_sym_start, + ACTIONS(1398), 1, + anon_sym_rec, + ACTIONS(1400), 1, + anon_sym_type, + STATE(782), 2, + sym__annotation, + sym_block_comment, + [56361] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1320), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(986), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(783), 2, + sym__annotation, + sym_block_comment, + [56409] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1318), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(978), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(784), 2, + sym__annotation, + sym_block_comment, + [56457] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1426), 1, + anon_sym_LPAREN, + ACTIONS(1439), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(988), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(785), 2, + sym__annotation, + sym_block_comment, + [56505] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1441), 1, + anon_sym_LPAREN, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(873), 1, + sym_result, + STATE(786), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1444), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56539] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1446), 1, + anon_sym_LPAREN, + STATE(871), 1, + sym_param, + STATE(787), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat1, + ACTIONS(1449), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56571] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1451), 1, + anon_sym_LPAREN, + STATE(873), 1, + sym_result, + STATE(788), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat2, + ACTIONS(1454), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56603] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1456), 1, + anon_sym_LPAREN, + STATE(788), 1, + aux_sym_block_block_repeat2, + STATE(873), 1, + sym_result, + STATE(789), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 9, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56637] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1311), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(957), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(790), 2, + sym__annotation, + sym_block_comment, + [56685] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1322), 1, + anon_sym_RPAREN, + ACTIONS(1426), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(981), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(791), 2, + sym__annotation, + sym_block_comment, + [56733] = 15, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1426), 1, + anon_sym_LPAREN, + ACTIONS(1459), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(987), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1089), 1, + sym_result, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(792), 2, + sym__annotation, + sym_block_comment, + [56781] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1463), 1, + sym_identifier, + STATE(793), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56810] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1465), 1, + anon_sym_LPAREN, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1079), 1, + sym_result, + STATE(794), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56843] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1468), 1, + anon_sym_LPAREN, + STATE(1054), 1, + sym_param, + STATE(795), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat1, + ACTIONS(1449), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56874] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1471), 1, + anon_sym_LPAREN, + STATE(1079), 1, + sym_result, + STATE(796), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat2, + ACTIONS(1454), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56905] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1474), 1, + anon_sym_LPAREN, + ACTIONS(1477), 1, + anon_sym_RPAREN, + STATE(1101), 1, + sym_catch, + STATE(797), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_try_table_repeat1, + ACTIONS(1479), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56938] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1481), 1, + anon_sym_LPAREN, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1079), 1, + sym_result, + STATE(798), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [56971] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1484), 1, + anon_sym_LPAREN, + STATE(796), 1, + aux_sym_block_block_repeat2, + STATE(1079), 1, + sym_result, + STATE(799), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1444), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57004] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1284), 1, + anon_sym_LPAREN, + ACTIONS(1487), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(817), 1, + aux_sym_elem_repeat2, + STATE(1418), 1, + sym__instr_folded, + STATE(1420), 1, + sym_elem_expr, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(800), 2, + sym__annotation, + sym_block_comment, + [57049] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1491), 1, + sym_identifier, + STATE(801), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1489), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57078] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1495), 1, + sym_identifier, + STATE(802), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1493), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57107] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1499), 1, + sym_identifier, + STATE(803), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1497), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57136] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1503), 1, + sym_identifier, + STATE(804), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1501), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57165] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1284), 1, + anon_sym_LPAREN, + ACTIONS(1505), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(800), 1, + aux_sym_elem_repeat2, + STATE(1418), 1, + sym__instr_folded, + STATE(1420), 1, + sym_elem_expr, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(805), 2, + sym__annotation, + sym_block_comment, + [57210] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1509), 1, + sym_identifier, + STATE(806), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57239] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1513), 1, + sym_identifier, + STATE(807), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57268] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1517), 1, + sym_identifier, + STATE(808), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57297] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1521), 1, + sym_identifier, + STATE(809), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57326] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1523), 1, + anon_sym_LPAREN, + ACTIONS(1525), 1, + sym_identifier, + ACTIONS(1527), 1, + sym_uinteger, + STATE(663), 1, + sym_export, + STATE(985), 1, + aux_sym_module_field_func_repeat1, + STATE(1217), 1, + sym_import, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(810), 2, + sym__annotation, + sym_block_comment, + STATE(1508), 2, + sym_data, + sym_mem_type, + [57369] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1334), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1336), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(811), 2, + sym__annotation, + sym_block_comment, + [57410] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1529), 1, + anon_sym_LPAREN, + STATE(1082), 1, + sym_catch, + STATE(812), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_try_table_repeat1, + ACTIONS(1479), 8, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57441] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1534), 1, + sym_identifier, + STATE(813), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57470] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1538), 1, + sym_identifier, + STATE(814), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57499] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1542), 1, + sym_identifier, + STATE(815), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57528] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1546), 1, + sym_identifier, + STATE(816), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57557] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1548), 1, + anon_sym_LPAREN, + ACTIONS(1551), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(1418), 1, + sym__instr_folded, + STATE(1420), 1, + sym_elem_expr, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(817), 3, + sym__annotation, + sym_block_comment, + aux_sym_elem_repeat2, + [57600] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1555), 1, + sym_identifier, + STATE(818), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57629] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1559), 1, + sym_identifier, + STATE(819), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57658] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1563), 1, + sym_identifier, + STATE(820), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57687] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1567), 1, + sym_identifier, + STATE(821), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57716] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1571), 1, + sym_identifier, + STATE(822), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57745] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1575), 1, + sym_identifier, + STATE(823), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57774] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1579), 1, + sym_identifier, + STATE(824), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57803] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1583), 1, + sym_identifier, + STATE(825), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57832] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1587), 1, + sym_identifier, + STATE(826), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57861] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1591), 1, + sym_identifier, + STATE(827), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57890] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1595), 1, + sym_identifier, + STATE(828), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57919] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1599), 1, + sym_identifier, + STATE(829), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57948] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1603), 1, + sym_identifier, + STATE(830), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [57977] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1417), 1, + anon_sym_RPAREN, + ACTIONS(1605), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(831), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1302), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58012] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1412), 1, + anon_sym_local, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(832), 2, + sym__annotation, + sym_block_comment, + [58057] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1608), 1, + anon_sym_LPAREN, + ACTIONS(1611), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(833), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat1, + ACTIONS(1449), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58090] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1613), 1, + anon_sym_LPAREN, + ACTIONS(1616), 1, + anon_sym_RPAREN, + STATE(1089), 1, + sym_result, + STATE(834), 3, + sym__annotation, + sym_block_comment, + aux_sym_block_block_repeat2, + ACTIONS(1454), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58123] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(973), 1, + anon_sym_RPAREN, + ACTIONS(1618), 1, + anon_sym_LPAREN, + STATE(1078), 1, + sym_export, + STATE(835), 3, + sym__annotation, + sym_block_comment, + aux_sym_module_field_func_repeat1, + ACTIONS(1621), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58156] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1623), 1, + anon_sym_LPAREN, + ACTIONS(1626), 1, + anon_sym_RPAREN, + STATE(1084), 1, + sym_local, + STATE(836), 3, + sym__annotation, + sym_block_comment, + aux_sym_module_field_func_repeat2, + ACTIONS(1628), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58189] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1630), 1, + anon_sym_LPAREN, + ACTIONS(1633), 1, + anon_sym_RPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(837), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1444), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58224] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1284), 1, + anon_sym_LPAREN, + ACTIONS(1635), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(817), 1, + aux_sym_elem_repeat2, + STATE(1418), 1, + sym__instr_folded, + STATE(1420), 1, + sym_elem_expr, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(838), 2, + sym__annotation, + sym_block_comment, + [58269] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1637), 1, + anon_sym_LPAREN, + ACTIONS(1639), 1, + anon_sym_final, + STATE(952), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1461), 1, + sym__composite_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(839), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [58308] = 14, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1641), 1, + anon_sym_then, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(840), 2, + sym__annotation, + sym_block_comment, + [58353] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + ACTIONS(1364), 2, + anon_sym_catch, + anon_sym_catch_ref, + ACTIONS(1366), 2, + anon_sym_catch_all, + anon_sym_catch_all_ref, + STATE(841), 2, + sym__annotation, + sym_block_comment, + [58394] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1422), 1, + anon_sym_RPAREN, + ACTIONS(1643), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(842), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1295), 7, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58429] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(843), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1174), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58455] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1646), 1, + anon_sym_RPAREN, + ACTIONS(1648), 1, + sym_identifier, + STATE(844), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58485] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1650), 1, + sym_identifier, + STATE(845), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58513] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1652), 1, + sym_identifier, + STATE(846), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58541] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1654), 1, + sym_identifier, + STATE(847), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58569] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1656), 1, + sym_identifier, + STATE(848), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58597] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1658), 1, + sym_identifier, + STATE(849), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58625] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1660), 1, + sym_identifier, + STATE(850), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58653] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1662), 1, + sym_identifier, + STATE(851), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58681] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1664), 1, + sym_identifier, + STATE(852), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58709] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1666), 1, + sym_identifier, + STATE(853), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58737] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1668), 1, + sym_identifier, + STATE(854), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58765] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1670), 1, + sym_identifier, + STATE(855), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58793] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1672), 1, + sym_identifier, + STATE(856), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58821] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1674), 1, + sym_identifier, + STATE(857), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58849] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1676), 1, + sym_identifier, + STATE(858), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58877] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1678), 1, + sym_identifier, + STATE(859), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58905] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1680), 1, + sym_identifier, + STATE(860), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58933] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1682), 1, + sym_identifier, + STATE(861), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58961] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1684), 1, + sym_identifier, + STATE(862), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [58989] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1686), 1, + anon_sym_RPAREN, + ACTIONS(1688), 1, + sym_identifier, + STATE(863), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59019] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(864), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1690), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59045] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(865), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1692), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59071] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(866), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1694), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59097] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(867), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1696), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59123] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(868), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1698), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59149] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(869), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59175] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(870), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1700), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59201] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(871), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1702), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59227] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(872), 2, + sym__annotation, + sym_block_comment, + ACTIONS(63), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59253] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(873), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1704), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59279] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1706), 1, + anon_sym_RPAREN, + ACTIONS(1708), 1, + sym_identifier, + STATE(874), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59309] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1338), 1, + anon_sym_param, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1342), 1, + anon_sym_type, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(875), 2, + sym__annotation, + sym_block_comment, + [59351] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1710), 1, + anon_sym_RPAREN, + ACTIONS(1712), 1, + sym_identifier, + STATE(876), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1489), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59381] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(877), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1714), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59407] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(878), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1716), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59433] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(879), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59459] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(880), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59485] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(881), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59511] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1718), 1, + sym_identifier, + STATE(882), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1489), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59539] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(883), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59565] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1720), 1, + sym_identifier, + STATE(884), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1493), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59593] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1722), 1, + sym_identifier, + STATE(885), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1497), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59621] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1724), 1, + sym_identifier, + STATE(886), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1501), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59649] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(887), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1726), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59675] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(888), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1728), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59701] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(889), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1730), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59727] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(890), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59753] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(891), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59779] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(892), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59805] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1732), 1, + anon_sym_RPAREN, + ACTIONS(1734), 1, + sym_identifier, + STATE(893), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59835] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(894), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59861] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(895), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1736), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59887] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(896), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59913] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(897), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59939] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(898), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59965] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(899), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [59991] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(900), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60017] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(901), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60043] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(902), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60069] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(903), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60095] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(904), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60121] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(905), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60147] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(906), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60173] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(907), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60199] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(908), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1738), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60225] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(909), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60251] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(910), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1740), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60277] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(911), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60303] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(912), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1742), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60329] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(913), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1744), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60355] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1746), 1, + anon_sym_RPAREN, + ACTIONS(1748), 1, + sym_identifier, + STATE(914), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1493), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60385] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(915), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1162), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60411] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(916), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1106), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60437] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(917), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1150), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60463] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(918), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1158), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60489] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(919), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1138), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60515] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(920), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1082), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60541] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(921), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1126), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60567] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(922), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1130), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60593] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(923), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1154), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60619] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(924), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1206), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60645] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(925), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1070), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60671] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(926), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1202), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60697] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(927), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1226), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60723] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(928), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1218), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60749] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(929), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1090), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60775] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(930), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1098), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60801] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1750), 1, + anon_sym_RPAREN, + ACTIONS(1752), 1, + sym_identifier, + STATE(931), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60831] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(932), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1178), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60857] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(933), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1210), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60883] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(934), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1074), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60909] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(935), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1078), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60935] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(936), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1086), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60961] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(937), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1110), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [60987] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(938), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1118), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61013] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(939), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1122), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61039] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(940), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1134), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61065] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(941), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1230), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61091] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(942), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1146), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61117] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(943), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1166), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61143] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(944), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1170), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61169] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(945), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1182), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61195] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(946), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1186), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61221] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(947), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1198), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61247] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1754), 1, + anon_sym_RPAREN, + ACTIONS(1756), 1, + sym_identifier, + STATE(948), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1497), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61277] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(949), 2, + sym__annotation, + sym_block_comment, + [61319] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1758), 1, + anon_sym_RPAREN, + ACTIONS(1760), 1, + sym_identifier, + STATE(950), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1501), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61349] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1637), 1, + anon_sym_LPAREN, + STATE(974), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1571), 1, + sym__composite_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(951), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [61385] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1637), 1, + anon_sym_LPAREN, + STATE(1222), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1571), 1, + sym__composite_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(952), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [61421] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1316), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(953), 2, + sym__annotation, + sym_block_comment, + [61463] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(69), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(954), 2, + sym__annotation, + sym_block_comment, + [61505] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1764), 1, + sym_identifier, + STATE(955), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61533] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1641), 1, + anon_sym_then, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(956), 2, + sym__annotation, + sym_block_comment, + [61575] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1318), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(957), 2, + sym__annotation, + sym_block_comment, + [61617] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1766), 1, + anon_sym_LPAREN, + ACTIONS(1769), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(958), 3, + sym__annotation, + sym_block_comment, + aux_sym__call_indirect_folded_repeat1, + [61657] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1771), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(959), 2, + sym__annotation, + sym_block_comment, + [61699] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1297), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(960), 2, + sym__annotation, + sym_block_comment, + [61741] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1773), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(961), 2, + sym__annotation, + sym_block_comment, + [61783] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1412), 1, + anon_sym_local, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(962), 2, + sym__annotation, + sym_block_comment, + [61825] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1775), 1, + sym_identifier, + STATE(963), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61853] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1777), 1, + anon_sym_RPAREN, + ACTIONS(1779), 1, + sym_identifier, + STATE(964), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61883] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1781), 1, + anon_sym_RPAREN, + ACTIONS(1783), 1, + sym_identifier, + STATE(965), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61913] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1428), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(966), 2, + sym__annotation, + sym_block_comment, + [61955] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1785), 1, + sym_identifier, + STATE(967), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [61983] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1787), 1, + anon_sym_RPAREN, + ACTIONS(1789), 1, + sym_identifier, + STATE(968), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62013] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1791), 1, + anon_sym_RPAREN, + ACTIONS(1793), 1, + sym_identifier, + STATE(969), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62043] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1795), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(970), 2, + sym__annotation, + sym_block_comment, + [62085] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1797), 1, + sym_identifier, + STATE(971), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62113] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1523), 1, + anon_sym_LPAREN, + ACTIONS(1527), 1, + sym_uinteger, + STATE(663), 1, + sym_export, + STATE(975), 1, + aux_sym_module_field_func_repeat1, + STATE(1220), 1, + sym_import, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(972), 2, + sym__annotation, + sym_block_comment, + STATE(1586), 2, + sym_data, + sym_mem_type, + [62153] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1372), 1, + anon_sym_type, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(973), 2, + sym__annotation, + sym_block_comment, + [62195] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1637), 1, + anon_sym_LPAREN, + STATE(1222), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + STATE(1450), 1, + sym__composite_type, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(974), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [62231] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1523), 1, + anon_sym_LPAREN, + ACTIONS(1527), 1, + sym_uinteger, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(663), 1, + sym_export, + STATE(1211), 1, + sym_import, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(975), 2, + sym__annotation, + sym_block_comment, + STATE(1611), 2, + sym_data, + sym_mem_type, + [62271] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1322), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(976), 2, + sym__annotation, + sym_block_comment, + [62313] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(103), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(977), 2, + sym__annotation, + sym_block_comment, + [62355] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1439), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(978), 2, + sym__annotation, + sym_block_comment, + [62397] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1811), 1, + anon_sym_RPAREN, + ACTIONS(1813), 1, + sym_identifier, + STATE(979), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62427] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1815), 1, + anon_sym_RPAREN, + ACTIONS(1817), 1, + sym_identifier, + STATE(980), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62457] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1320), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(981), 2, + sym__annotation, + sym_block_comment, + [62499] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1819), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(982), 2, + sym__annotation, + sym_block_comment, + [62541] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1821), 1, + anon_sym_RPAREN, + ACTIONS(1823), 1, + sym_identifier, + STATE(983), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62571] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1825), 1, + anon_sym_RPAREN, + ACTIONS(1827), 1, + sym_identifier, + STATE(984), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62601] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1523), 1, + anon_sym_LPAREN, + ACTIONS(1527), 1, + sym_uinteger, + STATE(566), 1, + aux_sym_module_field_func_repeat1, + STATE(663), 1, + sym_export, + STATE(1220), 1, + sym_import, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(985), 2, + sym__annotation, + sym_block_comment, + STATE(1586), 2, + sym_data, + sym_mem_type, + [62641] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1459), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(986), 2, + sym__annotation, + sym_block_comment, + [62683] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1829), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(987), 2, + sym__annotation, + sym_block_comment, + [62725] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1831), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(988), 2, + sym__annotation, + sym_block_comment, + [62767] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1290), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(989), 2, + sym__annotation, + sym_block_comment, + [62809] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(107), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(990), 2, + sym__annotation, + sym_block_comment, + [62851] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1833), 1, + anon_sym_RPAREN, + ACTIONS(1835), 1, + sym_identifier, + STATE(991), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62881] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1837), 1, + anon_sym_RPAREN, + ACTIONS(1839), 1, + sym_identifier, + STATE(992), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62911] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1841), 1, + anon_sym_RPAREN, + ACTIONS(1843), 1, + sym_identifier, + STATE(993), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62941] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1845), 1, + anon_sym_RPAREN, + ACTIONS(1847), 1, + sym_identifier, + STATE(994), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [62971] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1309), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(995), 2, + sym__annotation, + sym_block_comment, + [63013] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1849), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(996), 2, + sym__annotation, + sym_block_comment, + [63055] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1851), 1, + anon_sym_table, + ACTIONS(1853), 1, + anon_sym_offset, + ACTIONS(1855), 1, + anon_sym_ref, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(997), 2, + sym__annotation, + sym_block_comment, + [63097] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1430), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(998), 2, + sym__annotation, + sym_block_comment, + [63139] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + ACTIONS(1857), 1, + anon_sym_RPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(999), 2, + sym__annotation, + sym_block_comment, + [63181] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1859), 1, + anon_sym_block, + ACTIONS(1861), 1, + anon_sym_if, + ACTIONS(1863), 1, + anon_sym_loop, + ACTIONS(1865), 1, + anon_sym_try_table, + ACTIONS(1869), 1, + anon_sym_param, + ACTIONS(1871), 1, + anon_sym_result, + ACTIONS(1873), 1, + anon_sym_type, + ACTIONS(1875), 1, + sym_instr_name, + ACTIONS(1867), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1000), 2, + sym__annotation, + sym_block_comment, + [63223] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1311), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(1001), 2, + sym__annotation, + sym_block_comment, + [63265] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(58), 1, + anon_sym_RPAREN, + ACTIONS(1762), 1, + anon_sym_LPAREN, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(958), 1, + aux_sym__call_indirect_folded_repeat1, + STATE(1421), 1, + sym__instr_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(1002), 2, + sym__annotation, + sym_block_comment, + [63307] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1877), 1, + anon_sym_RPAREN, + ACTIONS(1879), 1, + sym_identifier, + STATE(1003), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63337] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1881), 1, + anon_sym_RPAREN, + ACTIONS(1883), 1, + sym_identifier, + STATE(1004), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63367] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1885), 1, + anon_sym_RPAREN, + ACTIONS(1887), 1, + sym_identifier, + STATE(1005), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63397] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1889), 1, + anon_sym_RPAREN, + ACTIONS(1891), 1, + sym_identifier, + STATE(1006), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63427] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1893), 1, + anon_sym_RPAREN, + ACTIONS(1895), 1, + sym_identifier, + STATE(1007), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63457] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1008), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1102), 10, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_else, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63483] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1889), 1, + anon_sym_RPAREN, + STATE(1009), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63510] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1010), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1134), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63535] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1011), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1230), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63560] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1148), 1, + anon_sym_RPAREN, + STATE(1012), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1146), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63587] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1152), 1, + anon_sym_RPAREN, + STATE(1013), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1150), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63614] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1168), 1, + anon_sym_RPAREN, + STATE(1014), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1166), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63641] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1160), 1, + anon_sym_RPAREN, + STATE(1015), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1158), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63668] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1172), 1, + anon_sym_RPAREN, + STATE(1016), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1170), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63695] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1140), 1, + anon_sym_RPAREN, + STATE(1017), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1138), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63722] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1176), 1, + anon_sym_RPAREN, + STATE(1018), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1174), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63749] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1019), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1714), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63774] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1020), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1146), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63799] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1156), 1, + anon_sym_RPAREN, + STATE(1021), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1154), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63826] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1022), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1170), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63851] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1023), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1174), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63876] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1024), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1738), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63901] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1025), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63926] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1026), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1716), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63951] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1220), 1, + anon_sym_RPAREN, + STATE(1027), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1218), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [63978] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1028), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1740), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64003] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1029), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64028] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1030), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1182), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64053] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1031), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1186), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64078] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1032), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64103] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1092), 1, + anon_sym_RPAREN, + STATE(1033), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1090), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64130] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1034), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1198), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64155] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1184), 1, + anon_sym_RPAREN, + STATE(1035), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1182), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64182] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1188), 1, + anon_sym_RPAREN, + STATE(1036), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1186), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64209] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1037), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1742), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64234] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1038), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1744), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64259] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1200), 1, + anon_sym_RPAREN, + STATE(1039), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1198), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64286] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1686), 1, + anon_sym_RPAREN, + STATE(1040), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64313] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1100), 1, + anon_sym_RPAREN, + STATE(1041), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1098), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64340] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1104), 1, + anon_sym_RPAREN, + STATE(1042), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1102), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64367] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1043), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1698), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64392] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1044), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1736), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64417] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1045), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64442] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1046), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1730), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64467] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1047), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64492] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1048), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64517] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1049), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64542] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1072), 1, + anon_sym_RPAREN, + STATE(1050), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1070), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64569] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1899), 1, + anon_sym_RPAREN, + STATE(1051), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1897), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64596] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1052), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64621] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1053), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1700), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64646] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1054), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1702), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64671] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1055), 2, + sym__annotation, + sym_block_comment, + ACTIONS(63), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64696] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1432), 1, + anon_sym_LPAREN, + STATE(597), 1, + sym_offset, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(1056), 2, + sym__annotation, + sym_block_comment, + [64735] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1706), 1, + anon_sym_RPAREN, + STATE(1057), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64762] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1058), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64787] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1059), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64812] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1180), 1, + anon_sym_RPAREN, + STATE(1060), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1178), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64839] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1061), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1162), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64864] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1062), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1106), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64889] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1063), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1150), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64914] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1901), 1, + anon_sym_RPAREN, + STATE(1064), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1744), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64941] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1065), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1158), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64966] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1066), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1138), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [64991] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1212), 1, + anon_sym_RPAREN, + STATE(1067), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1210), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65018] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1903), 1, + anon_sym_RPAREN, + STATE(1068), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1690), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65045] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1076), 1, + anon_sym_RPAREN, + STATE(1069), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1074), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65072] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1905), 1, + anon_sym_RPAREN, + STATE(1070), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1692), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65099] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1907), 1, + anon_sym_RPAREN, + STATE(1071), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1694), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65126] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1909), 1, + anon_sym_RPAREN, + STATE(1072), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1696), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65153] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1913), 1, + anon_sym_RPAREN, + STATE(1073), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1911), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65180] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1915), 1, + anon_sym_RPAREN, + STATE(1074), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1698), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65207] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1919), 1, + anon_sym_RPAREN, + STATE(1075), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1917), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65234] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1307), 1, + anon_sym_RPAREN, + STATE(1076), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1278), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65261] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1080), 1, + anon_sym_RPAREN, + STATE(1077), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1078), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65288] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1050), 1, + anon_sym_RPAREN, + STATE(1078), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1052), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65315] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1079), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1704), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65340] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1088), 1, + anon_sym_RPAREN, + STATE(1080), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1086), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65367] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1921), 1, + anon_sym_RPAREN, + STATE(1081), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1716), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65394] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1082), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1923), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65419] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1925), 1, + anon_sym_RPAREN, + STATE(1083), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1700), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65446] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1929), 1, + anon_sym_RPAREN, + STATE(1084), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1927), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65473] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1931), 1, + anon_sym_RPAREN, + STATE(1085), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1702), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65500] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(221), 1, + anon_sym_RPAREN, + STATE(1086), 2, + sym__annotation, + sym_block_comment, + ACTIONS(63), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65527] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1087), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65552] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1208), 1, + anon_sym_RPAREN, + STATE(1088), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1206), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65579] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1933), 1, + anon_sym_RPAREN, + STATE(1089), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1704), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65606] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1090), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65631] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1091), 2, + sym__annotation, + sym_block_comment, + [65670] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1092), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65695] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1641), 1, + anon_sym_then, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1093), 2, + sym__annotation, + sym_block_comment, + [65734] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1044), 1, + anon_sym_RPAREN, + STATE(1094), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1046), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65761] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(934), 1, + anon_sym_RPAREN, + STATE(1095), 2, + sym__annotation, + sym_block_comment, + ACTIONS(936), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65788] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1853), 1, + anon_sym_offset, + ACTIONS(1935), 1, + anon_sym_memory, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1096), 2, + sym__annotation, + sym_block_comment, + [65827] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1939), 1, + anon_sym_RPAREN, + STATE(1097), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1937), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65854] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1098), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65879] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1099), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1726), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65904] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1100), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65929] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1941), 1, + anon_sym_RPAREN, + STATE(1101), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1923), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65956] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1102), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1082), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [65981] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1103), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1126), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66006] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(281), 1, + anon_sym_RPAREN, + STATE(1104), 2, + sym__annotation, + sym_block_comment, + ACTIONS(279), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66033] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1105), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1130), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66058] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1054), 1, + anon_sym_RPAREN, + STATE(1106), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1056), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66085] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1945), 1, + anon_sym_RPAREN, + STATE(1107), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1943), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66112] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1108), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1154), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66137] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1947), 1, + anon_sym_RPAREN, + STATE(1109), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1726), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66164] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1949), 1, + anon_sym_RPAREN, + STATE(1110), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1728), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66191] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1951), 1, + anon_sym_RPAREN, + STATE(1111), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1730), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66218] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1777), 1, + anon_sym_RPAREN, + STATE(1112), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1532), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66245] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1113), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1206), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66270] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1412), 1, + anon_sym_local, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1114), 2, + sym__annotation, + sym_block_comment, + [66309] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1115), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1515), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66334] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1781), 1, + anon_sym_RPAREN, + STATE(1116), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1536), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66361] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1117), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1070), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66386] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1955), 1, + anon_sym_RPAREN, + STATE(1118), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1953), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66413] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1119), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66438] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1787), 1, + anon_sym_RPAREN, + STATE(1120), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1540), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66465] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1121), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66490] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1122), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1519), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66515] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1791), 1, + anon_sym_RPAREN, + STATE(1123), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1544), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66542] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1112), 1, + anon_sym_RPAREN, + STATE(1124), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1110), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66569] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1959), 1, + anon_sym_RPAREN, + STATE(1125), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1957), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66596] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1732), 1, + anon_sym_RPAREN, + STATE(1126), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1507), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66623] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1963), 1, + anon_sym_RPAREN, + STATE(1127), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1961), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66650] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1967), 1, + anon_sym_RPAREN, + STATE(1128), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1965), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66677] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1120), 1, + anon_sym_RPAREN, + STATE(1129), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1118), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66704] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1130), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1692), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66729] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1124), 1, + anon_sym_RPAREN, + STATE(1131), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1122), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66756] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1136), 1, + anon_sym_RPAREN, + STATE(1132), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1134), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66783] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1432), 1, + anon_sym_LPAREN, + STATE(507), 1, + sym_offset, + STATE(682), 1, + sym__instr_folded, + STATE(689), 1, + sym__block_if_folded, + STATE(701), 1, + sym__block_block_folded, + STATE(702), 1, + sym__block_loop_folded, + STATE(707), 1, + sym__block_try_table_folded, + STATE(670), 2, + sym__call_indirect_folded, + sym__plain_instr_folded, + STATE(1133), 2, + sym__annotation, + sym_block_comment, + [66822] = 13, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1969), 1, + anon_sym_LPAREN, + ACTIONS(1971), 1, + anon_sym_RPAREN, + ACTIONS(1973), 1, + sym_identifier, + STATE(1078), 1, + sym_export, + STATE(1085), 1, + sym_param, + STATE(1196), 1, + aux_sym_module_field_func_repeat1, + STATE(1247), 1, + sym_import, + STATE(1275), 1, + sym_type_use, + STATE(1277), 1, + aux_sym_block_block_repeat1, + STATE(1134), 2, + sym__annotation, + sym_block_comment, + [66863] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1368), 1, + anon_sym_param, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1135), 2, + sym__annotation, + sym_block_comment, + [66902] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1136), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1202), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66927] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(285), 1, + anon_sym_RPAREN, + STATE(1137), 2, + sym__annotation, + sym_block_comment, + ACTIONS(283), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66954] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1058), 1, + anon_sym_RPAREN, + STATE(1138), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1060), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [66981] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1977), 1, + anon_sym_RPAREN, + STATE(1139), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1975), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67008] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1979), 1, + anon_sym_RPAREN, + STATE(1140), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1736), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67035] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1811), 1, + anon_sym_RPAREN, + STATE(1141), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1553), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67062] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1142), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1226), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67087] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1815), 1, + anon_sym_RPAREN, + STATE(1143), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1557), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67114] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1144), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1218), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67139] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1145), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1090), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67164] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1146), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1098), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67189] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1821), 1, + anon_sym_RPAREN, + STATE(1147), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1561), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67216] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1148), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1102), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67241] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1149), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1897), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67266] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1825), 1, + anon_sym_RPAREN, + STATE(1150), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1461), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67293] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1151), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1694), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67318] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1232), 1, + anon_sym_RPAREN, + STATE(1152), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1230), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67345] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1153), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67370] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1338), 1, + anon_sym_param, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1154), 2, + sym__annotation, + sym_block_comment, + [67409] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1084), 1, + anon_sym_RPAREN, + STATE(1155), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1082), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67436] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1156), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1728), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67461] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1981), 1, + anon_sym_RPAREN, + STATE(1157), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1714), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67488] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1158), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67513] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1833), 1, + anon_sym_RPAREN, + STATE(1159), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1565), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67540] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1160), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1690), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67565] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1837), 1, + anon_sym_RPAREN, + STATE(1161), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1569), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67592] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1162), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1696), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67617] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1841), 1, + anon_sym_RPAREN, + STATE(1163), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1573), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67644] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1164), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1178), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67669] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1165), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1953), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67694] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1845), 1, + anon_sym_RPAREN, + STATE(1166), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1577), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67721] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1167), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1210), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67746] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1168), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1074), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67771] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1169), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1078), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67796] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1170), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1086), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67821] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1171), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67846] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1204), 1, + anon_sym_RPAREN, + STATE(1172), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1202), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67873] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1646), 1, + anon_sym_RPAREN, + STATE(1173), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1511), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67900] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(277), 1, + anon_sym_RPAREN, + STATE(1174), 2, + sym__annotation, + sym_block_comment, + ACTIONS(275), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67927] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1859), 1, + anon_sym_block, + ACTIONS(1861), 1, + anon_sym_if, + ACTIONS(1863), 1, + anon_sym_loop, + ACTIONS(1865), 1, + anon_sym_try_table, + ACTIONS(1869), 1, + anon_sym_param, + ACTIONS(1871), 1, + anon_sym_result, + ACTIONS(1875), 1, + sym_instr_name, + ACTIONS(1867), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1175), 2, + sym__annotation, + sym_block_comment, + [67966] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1128), 1, + anon_sym_RPAREN, + STATE(1176), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1126), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [67993] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1983), 1, + anon_sym_on, + ACTIONS(1985), 1, + anon_sym_ref, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1177), 2, + sym__annotation, + sym_block_comment, + [68032] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1178), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1593), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68057] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1877), 1, + anon_sym_RPAREN, + STATE(1179), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1581), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68084] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1164), 1, + anon_sym_RPAREN, + STATE(1180), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1162), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68111] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1881), 1, + anon_sym_RPAREN, + STATE(1181), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1585), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68138] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1228), 1, + anon_sym_RPAREN, + STATE(1182), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1226), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68165] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1885), 1, + anon_sym_RPAREN, + STATE(1183), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1589), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68192] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1108), 1, + anon_sym_RPAREN, + STATE(1184), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1106), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68219] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1989), 1, + anon_sym_RPAREN, + STATE(1185), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1987), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68246] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1186), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1110), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68271] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1991), 1, + anon_sym_RPAREN, + STATE(1187), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1738), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68298] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1893), 1, + anon_sym_RPAREN, + STATE(1188), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1597), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68325] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1189), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1118), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68350] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1993), 1, + anon_sym_RPAREN, + STATE(1190), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1740), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68377] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1750), 1, + anon_sym_RPAREN, + STATE(1191), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1601), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68404] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1192), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1122), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68429] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1132), 1, + anon_sym_RPAREN, + STATE(1193), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1130), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68456] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1995), 1, + anon_sym_RPAREN, + STATE(1194), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1742), 8, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68483] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1195), 2, + sym__annotation, + sym_block_comment, + ACTIONS(1166), 9, + anon_sym_LPAREN, + anon_sym_block, + anon_sym_end, + anon_sym_if, + anon_sym_loop, + anon_sym_try_table, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + sym_instr_name, + [68508] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1969), 1, + anon_sym_LPAREN, + ACTIONS(1997), 1, + anon_sym_RPAREN, + STATE(835), 1, + aux_sym_module_field_func_repeat1, + STATE(1078), 1, + sym_export, + STATE(1085), 1, + sym_param, + STATE(1237), 1, + sym_import, + STATE(1263), 1, + sym_type_use, + STATE(1287), 1, + aux_sym_block_block_repeat1, + STATE(1196), 2, + sym__annotation, + sym_block_comment, + [68546] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1197), 2, + sym__annotation, + sym_block_comment, + [68582] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1969), 1, + anon_sym_LPAREN, + ACTIONS(1999), 1, + anon_sym_RPAREN, + STATE(835), 1, + aux_sym_module_field_func_repeat1, + STATE(1078), 1, + sym_export, + STATE(1085), 1, + sym_param, + STATE(1240), 1, + sym_import, + STATE(1249), 1, + sym_type_use, + STATE(1250), 1, + aux_sym_block_block_repeat1, + STATE(1198), 2, + sym__annotation, + sym_block_comment, + [68620] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1370), 1, + anon_sym_result, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1199), 2, + sym__annotation, + sym_block_comment, + [68656] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1641), 1, + anon_sym_then, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1200), 2, + sym__annotation, + sym_block_comment, + [68692] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1340), 1, + anon_sym_result, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1201), 2, + sym__annotation, + sym_block_comment, + [68728] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1412), 1, + anon_sym_local, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1202), 2, + sym__annotation, + sym_block_comment, + [68764] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2001), 1, + anon_sym_LPAREN, + ACTIONS(2003), 1, + sym_identifier, + STATE(1502), 1, + sym__composite_type, + STATE(1506), 1, + sym_sub_type, + STATE(1203), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [68796] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1859), 1, + anon_sym_block, + ACTIONS(1861), 1, + anon_sym_if, + ACTIONS(1863), 1, + anon_sym_loop, + ACTIONS(1865), 1, + anon_sym_try_table, + ACTIONS(1871), 1, + anon_sym_result, + ACTIONS(1875), 1, + sym_instr_name, + ACTIONS(1867), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1204), 2, + sym__annotation, + sym_block_comment, + [68832] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2005), 1, + anon_sym_LPAREN, + ACTIONS(2007), 1, + anon_sym_RPAREN, + ACTIONS(2009), 1, + sym_identifier, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1232), 1, + sym_type_use, + STATE(1233), 1, + aux_sym_block_block_repeat1, + STATE(1272), 1, + aux_sym_block_block_repeat2, + STATE(1205), 2, + sym__annotation, + sym_block_comment, + [68870] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(2011), 1, + anon_sym_item, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1206), 2, + sym__annotation, + sym_block_comment, + [68906] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1853), 1, + anon_sym_offset, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1207), 2, + sym__annotation, + sym_block_comment, + [68942] = 12, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1969), 1, + anon_sym_LPAREN, + ACTIONS(1997), 1, + anon_sym_RPAREN, + STATE(1078), 1, + sym_export, + STATE(1085), 1, + sym_param, + STATE(1198), 1, + aux_sym_module_field_func_repeat1, + STATE(1237), 1, + sym_import, + STATE(1263), 1, + sym_type_use, + STATE(1287), 1, + aux_sym_block_block_repeat1, + STATE(1208), 2, + sym__annotation, + sym_block_comment, + [68980] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1354), 1, + anon_sym_block, + ACTIONS(1356), 1, + anon_sym_if, + ACTIONS(1358), 1, + anon_sym_loop, + ACTIONS(1360), 1, + anon_sym_try_table, + ACTIONS(1374), 1, + sym_instr_name, + ACTIONS(1362), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1209), 2, + sym__annotation, + sym_block_comment, + [69013] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2013), 1, + anon_sym_LPAREN, + STATE(1492), 1, + sym__extern_type, + STATE(1210), 2, + sym__annotation, + sym_block_comment, + STATE(1570), 5, + sym_extern_type_func, + sym_extern_type_global, + sym_extern_type_memory, + sym_extern_type_table, + sym_extern_type_tag, + [69040] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1527), 1, + sym_uinteger, + ACTIONS(2015), 1, + anon_sym_LPAREN, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1211), 2, + sym__annotation, + sym_block_comment, + STATE(1471), 2, + sym_data, + sym_mem_type, + [69071] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2019), 1, + anon_sym_RPAREN, + ACTIONS(2023), 1, + sym_uinteger, + STATE(1293), 1, + sym_share, + STATE(1632), 1, + sym_mem_page_size, + ACTIONS(2021), 2, + anon_sym_shared, + anon_sym_unshared, + STATE(1212), 2, + sym__annotation, + sym_block_comment, + [69104] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1324), 1, + anon_sym_block, + ACTIONS(1326), 1, + anon_sym_if, + ACTIONS(1328), 1, + anon_sym_loop, + ACTIONS(1330), 1, + anon_sym_try_table, + ACTIONS(1344), 1, + sym_instr_name, + ACTIONS(1332), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1213), 2, + sym__annotation, + sym_block_comment, + [69137] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1799), 1, + anon_sym_block, + ACTIONS(1801), 1, + anon_sym_if, + ACTIONS(1803), 1, + anon_sym_loop, + ACTIONS(1805), 1, + anon_sym_try_table, + ACTIONS(1809), 1, + sym_instr_name, + ACTIONS(1807), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1214), 2, + sym__annotation, + sym_block_comment, + [69170] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2025), 1, + anon_sym_RPAREN, + ACTIONS(2027), 1, + sym_uinteger, + STATE(1299), 1, + sym_share, + STATE(1454), 1, + sym_mem_page_size, + ACTIONS(2021), 2, + anon_sym_shared, + anon_sym_unshared, + STATE(1215), 2, + sym__annotation, + sym_block_comment, + [69203] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2001), 1, + anon_sym_LPAREN, + STATE(1502), 1, + sym__composite_type, + STATE(1573), 1, + sym_sub_type, + STATE(1216), 2, + sym__annotation, + sym_block_comment, + STATE(1493), 4, + sym_array_type, + sym_cont_type, + sym_func_type, + sym_struct_type, + [69232] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1527), 1, + sym_uinteger, + ACTIONS(2015), 1, + anon_sym_LPAREN, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1217), 2, + sym__annotation, + sym_block_comment, + STATE(1586), 2, + sym_data, + sym_mem_type, + [69263] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1859), 1, + anon_sym_block, + ACTIONS(1861), 1, + anon_sym_if, + ACTIONS(1863), 1, + anon_sym_loop, + ACTIONS(1865), 1, + anon_sym_try_table, + ACTIONS(1875), 1, + sym_instr_name, + ACTIONS(1867), 2, + anon_sym_call_indirect, + anon_sym_return_call_indirect, + STATE(1218), 2, + sym__annotation, + sym_block_comment, + [69296] = 11, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2005), 1, + anon_sym_LPAREN, + ACTIONS(2029), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1226), 1, + sym_type_use, + STATE(1228), 1, + aux_sym_block_block_repeat1, + STATE(1279), 1, + aux_sym_block_block_repeat2, + STATE(1219), 2, + sym__annotation, + sym_block_comment, + [69331] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1527), 1, + sym_uinteger, + ACTIONS(2015), 1, + anon_sym_LPAREN, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1220), 2, + sym__annotation, + sym_block_comment, + STATE(1611), 2, + sym_data, + sym_mem_type, + [69362] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2031), 1, + anon_sym_LPAREN, + ACTIONS(2033), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1264), 1, + aux_sym_block_block_repeat2, + STATE(1221), 2, + sym__annotation, + sym_block_comment, + [69394] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2035), 1, + anon_sym_LPAREN, + ACTIONS(2037), 1, + anon_sym_RPAREN, + STATE(1251), 1, + sym_index, + ACTIONS(2039), 2, + sym_identifier, + sym_uinteger, + STATE(1222), 3, + sym__annotation, + sym_block_comment, + aux_sym_elem_repeat1, + [69422] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2042), 1, + anon_sym_RPAREN, + STATE(1386), 1, + sym_share, + STATE(1484), 1, + sym_mem_page_size, + ACTIONS(2021), 2, + anon_sym_shared, + anon_sym_unshared, + STATE(1223), 2, + sym__annotation, + sym_block_comment, + [69452] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2044), 1, + anon_sym_RPAREN, + STATE(1404), 1, + sym_share, + STATE(1616), 1, + sym_mem_page_size, + ACTIONS(2021), 2, + anon_sym_shared, + anon_sym_unshared, + STATE(1224), 2, + sym__annotation, + sym_block_comment, + [69482] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(816), 1, + sym_uinteger, + ACTIONS(2046), 1, + sym_identifier, + STATE(1540), 1, + sym_addr_type, + STATE(1631), 1, + sym_table_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1225), 2, + sym__annotation, + sym_block_comment, + [69512] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2031), 1, + anon_sym_LPAREN, + ACTIONS(2048), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1221), 1, + aux_sym_block_block_repeat1, + STATE(1283), 1, + aux_sym_block_block_repeat2, + STATE(1226), 2, + sym__annotation, + sym_block_comment, + [69544] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1527), 1, + sym_uinteger, + ACTIONS(2050), 1, + sym_identifier, + STATE(1547), 1, + sym_mem_type, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1227), 2, + sym__annotation, + sym_block_comment, + [69574] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2031), 1, + anon_sym_LPAREN, + ACTIONS(2048), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1283), 1, + aux_sym_block_block_repeat2, + STATE(1228), 2, + sym__annotation, + sym_block_comment, + [69606] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2031), 1, + anon_sym_LPAREN, + ACTIONS(2052), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1231), 1, + aux_sym_block_block_repeat1, + STATE(1258), 1, + aux_sym_block_block_repeat2, + STATE(1229), 2, + sym__annotation, + sym_block_comment, + [69638] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2054), 1, + anon_sym_LPAREN, + ACTIONS(2056), 1, + anon_sym_RPAREN, + ACTIONS(2058), 1, + sym_identifier, + STATE(1085), 1, + sym_param, + STATE(1273), 1, + sym_type_use, + STATE(1274), 1, + aux_sym_block_block_repeat1, + STATE(1230), 2, + sym__annotation, + sym_block_comment, + [69670] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2031), 1, + anon_sym_LPAREN, + ACTIONS(2060), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1259), 1, + aux_sym_block_block_repeat2, + STATE(1231), 2, + sym__annotation, + sym_block_comment, + [69702] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2029), 1, + anon_sym_RPAREN, + ACTIONS(2031), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1228), 1, + aux_sym_block_block_repeat1, + STATE(1279), 1, + aux_sym_block_block_repeat2, + STATE(1232), 2, + sym__annotation, + sym_block_comment, + [69734] = 10, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2029), 1, + anon_sym_RPAREN, + ACTIONS(2031), 1, + anon_sym_LPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1089), 1, + sym_result, + STATE(1279), 1, + aux_sym_block_block_repeat2, + STATE(1233), 2, + sym__annotation, + sym_block_comment, + [69766] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2062), 1, + anon_sym_array, + ACTIONS(2064), 1, + anon_sym_cont, + ACTIONS(2066), 1, + anon_sym_func, + ACTIONS(2068), 1, + anon_sym_struct, + ACTIONS(2070), 1, + anon_sym_sub, + STATE(1234), 2, + sym__annotation, + sym_block_comment, + [69795] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1635), 1, + anon_sym_RPAREN, + STATE(1222), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1235), 2, + sym__annotation, + sym_block_comment, + [69822] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(271), 1, + anon_sym_LPAREN, + STATE(1236), 2, + sym__annotation, + sym_block_comment, + ACTIONS(273), 4, + anon_sym_RPAREN, + anon_sym_switch, + sym_identifier, + sym_uinteger, + [69845] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1999), 1, + anon_sym_RPAREN, + ACTIONS(2054), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1249), 1, + sym_type_use, + STATE(1250), 1, + aux_sym_block_block_repeat1, + STATE(1237), 2, + sym__annotation, + sym_block_comment, + [69874] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1505), 1, + anon_sym_RPAREN, + STATE(1246), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1238), 2, + sym__annotation, + sym_block_comment, + [69901] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1239), 2, + sym__annotation, + sym_block_comment, + ACTIONS(2072), 5, + anon_sym_func, + anon_sym_global, + anon_sym_table, + anon_sym_memory, + anon_sym_tag, + [69922] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2054), 1, + anon_sym_LPAREN, + ACTIONS(2074), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1256), 1, + aux_sym_block_block_repeat1, + STATE(1257), 1, + sym_type_use, + STATE(1240), 2, + sym__annotation, + sym_block_comment, + [69951] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1505), 1, + anon_sym_RPAREN, + STATE(1222), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1241), 2, + sym__annotation, + sym_block_comment, + [69978] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(816), 1, + sym_uinteger, + STATE(1530), 1, + sym_table_type, + STATE(1540), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1242), 2, + sym__annotation, + sym_block_comment, + [70005] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2076), 1, + anon_sym_func, + ACTIONS(2078), 1, + anon_sym_global, + ACTIONS(2080), 1, + anon_sym_table, + ACTIONS(2082), 1, + anon_sym_memory, + ACTIONS(2084), 1, + anon_sym_tag, + STATE(1243), 2, + sym__annotation, + sym_block_comment, + [70034] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1527), 1, + sym_uinteger, + STATE(1532), 1, + sym_mem_type, + STATE(1579), 1, + sym_addr_type, + ACTIONS(810), 2, + anon_sym_i32, + anon_sym_i64, + STATE(1244), 2, + sym__annotation, + sym_block_comment, + [70061] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2054), 1, + anon_sym_LPAREN, + ACTIONS(2086), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1280), 1, + sym_type_use, + STATE(1281), 1, + aux_sym_block_block_repeat1, + STATE(1245), 2, + sym__annotation, + sym_block_comment, + [70090] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1487), 1, + anon_sym_RPAREN, + STATE(1222), 1, + aux_sym_elem_repeat1, + STATE(1251), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1246), 2, + sym__annotation, + sym_block_comment, + [70117] = 9, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1997), 1, + anon_sym_RPAREN, + ACTIONS(2054), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1263), 1, + sym_type_use, + STATE(1287), 1, + aux_sym_block_block_repeat1, + STATE(1247), 2, + sym__annotation, + sym_block_comment, + [70146] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2088), 1, + anon_sym_switch, + STATE(1617), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1248), 2, + sym__annotation, + sym_block_comment, + [70170] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2074), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1256), 1, + aux_sym_block_block_repeat1, + STATE(1249), 2, + sym__annotation, + sym_block_comment, + [70196] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2074), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1250), 2, + sym__annotation, + sym_block_comment, + [70222] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2092), 1, + anon_sym_LPAREN, + STATE(1251), 2, + sym__annotation, + sym_block_comment, + ACTIONS(2094), 3, + anon_sym_RPAREN, + sym_identifier, + sym_uinteger, + [70244] = 8, + ACTIONS(2096), 1, + anon_sym_RPAREN, + ACTIONS(2098), 1, + sym_annotation_start, + ACTIONS(2100), 1, + sym_annotation_elem, + ACTIONS(2102), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(2104), 1, + sym_line_comment, + STATE(1339), 1, + aux_sym__annotation_repeat1, + STATE(1637), 1, + sym_annotation_end, + STATE(1252), 2, + sym__annotation, + sym_block_comment, + [70270] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1334), 1, + anon_sym_catch, + ACTIONS(1336), 1, + anon_sym_catch_all, + ACTIONS(2106), 1, + anon_sym_catch_ref, + ACTIONS(2108), 1, + anon_sym_catch_all_ref, + STATE(1253), 2, + sym__annotation, + sym_block_comment, + [70296] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2110), 1, + anon_sym_switch, + STATE(1577), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1254), 2, + sym__annotation, + sym_block_comment, + [70320] = 8, + ACTIONS(2096), 1, + anon_sym_RPAREN, + ACTIONS(2098), 1, + sym_annotation_start, + ACTIONS(2100), 1, + sym_annotation_elem, + ACTIONS(2102), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(2104), 1, + sym_line_comment, + STATE(1252), 1, + aux_sym__annotation_repeat1, + STATE(1639), 1, + sym_annotation_end, + STATE(1255), 2, + sym__annotation, + sym_block_comment, + [70346] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2112), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1256), 2, + sym__annotation, + sym_block_comment, + [70372] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2112), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1271), 1, + aux_sym_block_block_repeat1, + STATE(1257), 2, + sym__annotation, + sym_block_comment, + [70398] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2060), 1, + anon_sym_RPAREN, + ACTIONS(2114), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1258), 2, + sym__annotation, + sym_block_comment, + [70424] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2114), 1, + anon_sym_LPAREN, + ACTIONS(2116), 1, + anon_sym_RPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1259), 2, + sym__annotation, + sym_block_comment, + [70450] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2118), 1, + anon_sym_LPAREN, + ACTIONS(2121), 1, + anon_sym_RPAREN, + STATE(1435), 1, + sym_field, + STATE(1260), 3, + sym__annotation, + sym_block_comment, + aux_sym_struct_type_repeat1, + [70474] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2123), 1, + anon_sym_LPAREN, + ACTIONS(2125), 1, + anon_sym_RPAREN, + STATE(1260), 1, + aux_sym_struct_type_repeat1, + STATE(1435), 1, + sym_field, + STATE(1261), 2, + sym__annotation, + sym_block_comment, + [70500] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2062), 1, + anon_sym_array, + ACTIONS(2064), 1, + anon_sym_cont, + ACTIONS(2066), 1, + anon_sym_func, + ACTIONS(2068), 1, + anon_sym_struct, + STATE(1262), 2, + sym__annotation, + sym_block_comment, + [70526] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1999), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1250), 1, + aux_sym_block_block_repeat1, + STATE(1263), 2, + sym__annotation, + sym_block_comment, + [70552] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2114), 1, + anon_sym_LPAREN, + ACTIONS(2127), 1, + anon_sym_RPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1264), 2, + sym__annotation, + sym_block_comment, + [70578] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1265), 1, + ts_builtin_sym_end, + ACTIONS(2129), 1, + anon_sym_LPAREN, + STATE(1267), 1, + aux_sym_root_repeat1, + STATE(1428), 1, + sym_module, + STATE(1265), 2, + sym__annotation, + sym_block_comment, + [70604] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2131), 1, + anon_sym_LPAREN, + ACTIONS(2133), 1, + anon_sym_RPAREN, + STATE(1278), 1, + aux_sym_rec_type_repeat1, + STATE(1449), 1, + sym_type_def, + STATE(1266), 2, + sym__annotation, + sym_block_comment, + [70630] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2135), 1, + ts_builtin_sym_end, + ACTIONS(2137), 1, + anon_sym_LPAREN, + STATE(1428), 1, + sym_module, + STATE(1267), 3, + sym__annotation, + sym_block_comment, + aux_sym_root_repeat1, + [70654] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2140), 1, + anon_sym_LPAREN, + ACTIONS(2143), 1, + anon_sym_RPAREN, + STATE(1449), 1, + sym_type_def, + STATE(1268), 3, + sym__annotation, + sym_block_comment, + aux_sym_rec_type_repeat1, + [70678] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2123), 1, + anon_sym_LPAREN, + ACTIONS(2145), 1, + anon_sym_RPAREN, + STATE(1261), 1, + aux_sym_struct_type_repeat1, + STATE(1435), 1, + sym_field, + STATE(1269), 2, + sym__annotation, + sym_block_comment, + [70704] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2147), 1, + anon_sym_export, + ACTIONS(2149), 1, + anon_sym_import, + ACTIONS(2151), 1, + anon_sym_param, + ACTIONS(2153), 1, + anon_sym_type, + STATE(1270), 2, + sym__annotation, + sym_block_comment, + [70730] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2155), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1271), 2, + sym__annotation, + sym_block_comment, + [70756] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2029), 1, + anon_sym_RPAREN, + ACTIONS(2114), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1272), 2, + sym__annotation, + sym_block_comment, + [70782] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2086), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1281), 1, + aux_sym_block_block_repeat1, + STATE(1273), 2, + sym__annotation, + sym_block_comment, + [70808] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2086), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1274), 2, + sym__annotation, + sym_block_comment, + [70834] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1997), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(1085), 1, + sym_param, + STATE(1287), 1, + aux_sym_block_block_repeat1, + STATE(1275), 2, + sym__annotation, + sym_block_comment, + [70860] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_export, + ACTIONS(2159), 1, + anon_sym_mut, + ACTIONS(2161), 1, + anon_sym_import, + ACTIONS(2163), 1, + anon_sym_ref, + STATE(1276), 2, + sym__annotation, + sym_block_comment, + [70886] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1997), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1277), 2, + sym__annotation, + sym_block_comment, + [70912] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2131), 1, + anon_sym_LPAREN, + ACTIONS(2165), 1, + anon_sym_RPAREN, + STATE(1268), 1, + aux_sym_rec_type_repeat1, + STATE(1449), 1, + sym_type_def, + STATE(1278), 2, + sym__annotation, + sym_block_comment, + [70938] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2048), 1, + anon_sym_RPAREN, + ACTIONS(2114), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1279), 2, + sym__annotation, + sym_block_comment, + [70964] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2167), 1, + anon_sym_RPAREN, + STATE(1085), 1, + sym_param, + STATE(1285), 1, + aux_sym_block_block_repeat1, + STATE(1280), 2, + sym__annotation, + sym_block_comment, + [70990] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2167), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1281), 2, + sym__annotation, + sym_block_comment, + [71016] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1364), 1, + anon_sym_catch, + ACTIONS(1366), 1, + anon_sym_catch_all, + ACTIONS(2169), 1, + anon_sym_catch_ref, + ACTIONS(2171), 1, + anon_sym_catch_all_ref, + STATE(1282), 2, + sym__annotation, + sym_block_comment, + [71042] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2033), 1, + anon_sym_RPAREN, + ACTIONS(2114), 1, + anon_sym_LPAREN, + STATE(834), 1, + aux_sym_block_block_repeat2, + STATE(1089), 1, + sym_result, + STATE(1283), 2, + sym__annotation, + sym_block_comment, + [71068] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2173), 1, + anon_sym_switch, + STATE(1612), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1284), 2, + sym__annotation, + sym_block_comment, + [71092] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2090), 1, + anon_sym_LPAREN, + ACTIONS(2175), 1, + anon_sym_RPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1285), 2, + sym__annotation, + sym_block_comment, + [71118] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2177), 1, + anon_sym_switch, + STATE(1525), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1286), 2, + sym__annotation, + sym_block_comment, + [71142] = 8, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1999), 1, + anon_sym_RPAREN, + ACTIONS(2090), 1, + anon_sym_LPAREN, + STATE(833), 1, + aux_sym_block_block_repeat1, + STATE(1085), 1, + sym_param, + STATE(1287), 2, + sym__annotation, + sym_block_comment, + [71168] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2181), 1, + anon_sym_LPAREN, + ACTIONS(2179), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1288), 2, + sym__annotation, + sym_block_comment, + [71189] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2185), 1, + anon_sym_LPAREN, + ACTIONS(2183), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1289), 2, + sym__annotation, + sym_block_comment, + [71210] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2187), 1, + anon_sym_param, + ACTIONS(2189), 1, + anon_sym_result, + ACTIONS(2191), 1, + anon_sym_type, + STATE(1290), 2, + sym__annotation, + sym_block_comment, + [71233] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2193), 1, + anon_sym_end, + ACTIONS(2195), 1, + anon_sym_else, + STATE(1490), 1, + sym_block_if_else, + STATE(1291), 2, + sym__annotation, + sym_block_comment, + [71256] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2199), 1, + anon_sym_RPAREN, + STATE(1499), 1, + sym__block_if_else_folded, + STATE(1292), 2, + sym__annotation, + sym_block_comment, + [71279] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2201), 1, + anon_sym_RPAREN, + STATE(1487), 1, + sym_mem_page_size, + STATE(1293), 2, + sym__annotation, + sym_block_comment, + [71302] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2203), 1, + anon_sym_RPAREN, + STATE(1495), 1, + sym__block_if_else_folded, + STATE(1294), 2, + sym__annotation, + sym_block_comment, + [71325] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2207), 1, + anon_sym_LPAREN, + ACTIONS(2205), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1295), 2, + sym__annotation, + sym_block_comment, + [71346] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2209), 1, + anon_sym_end, + STATE(1513), 1, + sym_block_if_else, + STATE(1296), 2, + sym__annotation, + sym_block_comment, + [71369] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2211), 1, + anon_sym_RPAREN, + STATE(1473), 1, + sym__block_if_else_folded, + STATE(1297), 2, + sym__annotation, + sym_block_comment, + [71392] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2215), 1, + anon_sym_LPAREN, + ACTIONS(2213), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1298), 2, + sym__annotation, + sym_block_comment, + [71413] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2217), 1, + anon_sym_RPAREN, + STATE(1620), 1, + sym_mem_page_size, + STATE(1299), 2, + sym__annotation, + sym_block_comment, + [71436] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2219), 1, + anon_sym_RPAREN, + ACTIONS(2221), 1, + sym_string, + STATE(1300), 3, + sym__annotation, + sym_block_comment, + aux_sym_data_repeat1, + [71457] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2226), 1, + anon_sym_LPAREN, + ACTIONS(2224), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1301), 2, + sym__annotation, + sym_block_comment, + [71478] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2228), 1, + anon_sym_end, + STATE(1538), 1, + sym_block_if_else, + STATE(1302), 2, + sym__annotation, + sym_block_comment, + [71501] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2232), 1, + anon_sym_LPAREN, + ACTIONS(2230), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1303), 2, + sym__annotation, + sym_block_comment, + [71522] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2236), 1, + anon_sym_LPAREN, + ACTIONS(2234), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1304), 2, + sym__annotation, + sym_block_comment, + [71543] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2240), 1, + anon_sym_LPAREN, + ACTIONS(2238), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1305), 2, + sym__annotation, + sym_block_comment, + [71564] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2244), 1, + anon_sym_LPAREN, + ACTIONS(2242), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1306), 2, + sym__annotation, + sym_block_comment, + [71585] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2246), 1, + anon_sym_RPAREN, + STATE(1501), 1, + sym__block_if_else_folded, + STATE(1307), 2, + sym__annotation, + sym_block_comment, + [71608] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2250), 1, + anon_sym_LPAREN, + ACTIONS(2248), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1308), 2, + sym__annotation, + sym_block_comment, + [71629] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2252), 1, + anon_sym_end, + STATE(1512), 1, + sym_block_if_else, + STATE(1309), 2, + sym__annotation, + sym_block_comment, + [71652] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2256), 1, + anon_sym_LPAREN, + ACTIONS(2254), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1310), 2, + sym__annotation, + sym_block_comment, + [71673] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1481), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1311), 2, + sym__annotation, + sym_block_comment, + [71694] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2258), 1, + anon_sym_RPAREN, + STATE(1574), 1, + sym__block_if_else_folded, + STATE(1312), 2, + sym__annotation, + sym_block_comment, + [71717] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1254), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1313), 2, + sym__annotation, + sym_block_comment, + [71738] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2260), 1, + anon_sym_RPAREN, + STATE(1604), 1, + sym__block_if_else_folded, + STATE(1314), 2, + sym__annotation, + sym_block_comment, + [71761] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2262), 1, + anon_sym_end, + STATE(1498), 1, + sym_block_if_else, + STATE(1315), 2, + sym__annotation, + sym_block_comment, + [71784] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2266), 1, + anon_sym_LPAREN, + ACTIONS(2264), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1316), 2, + sym__annotation, + sym_block_comment, + [71805] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2151), 1, + anon_sym_param, + ACTIONS(2153), 1, + anon_sym_type, + ACTIONS(2268), 1, + anon_sym_result, + STATE(1317), 2, + sym__annotation, + sym_block_comment, + [71828] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2272), 1, + anon_sym_LPAREN, + ACTIONS(2270), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1318), 2, + sym__annotation, + sym_block_comment, + [71849] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2274), 1, + anon_sym_end, + STATE(1596), 1, + sym_block_if_else, + STATE(1319), 2, + sym__annotation, + sym_block_comment, + [71872] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2276), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym__block_if_else_folded, + STATE(1320), 2, + sym__annotation, + sym_block_comment, + [71895] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1509), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1321), 2, + sym__annotation, + sym_block_comment, + [71916] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1496), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1322), 2, + sym__annotation, + sym_block_comment, + [71937] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2280), 1, + anon_sym_LPAREN, + ACTIONS(2278), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1323), 2, + sym__annotation, + sym_block_comment, + [71958] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2284), 1, + anon_sym_LPAREN, + ACTIONS(2282), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1324), 2, + sym__annotation, + sym_block_comment, + [71979] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2286), 1, + anon_sym_end, + STATE(1568), 1, + sym_block_if_else, + STATE(1325), 2, + sym__annotation, + sym_block_comment, + [72002] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2288), 1, + anon_sym_RPAREN, + STATE(1618), 1, + sym__block_if_else_folded, + STATE(1326), 2, + sym__annotation, + sym_block_comment, + [72025] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2292), 1, + anon_sym_LPAREN, + ACTIONS(2290), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1327), 2, + sym__annotation, + sym_block_comment, + [72046] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2296), 1, + anon_sym_LPAREN, + ACTIONS(2294), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1328), 2, + sym__annotation, + sym_block_comment, + [72067] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2300), 1, + anon_sym_LPAREN, + ACTIONS(2298), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1329), 2, + sym__annotation, + sym_block_comment, + [72088] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2304), 1, + anon_sym_LPAREN, + ACTIONS(2302), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1330), 2, + sym__annotation, + sym_block_comment, + [72109] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2308), 1, + anon_sym_LPAREN, + ACTIONS(2306), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1331), 2, + sym__annotation, + sym_block_comment, + [72130] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2310), 1, + anon_sym_end, + STATE(1633), 1, + sym_block_if_else, + STATE(1332), 2, + sym__annotation, + sym_block_comment, + [72153] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2312), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1333), 2, + sym__annotation, + sym_block_comment, + [72174] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2318), 1, + anon_sym_LPAREN, + ACTIONS(2316), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1334), 2, + sym__annotation, + sym_block_comment, + [72195] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2320), 1, + anon_sym_end, + STATE(1567), 1, + sym_block_if_else, + STATE(1335), 2, + sym__annotation, + sym_block_comment, + [72218] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_RPAREN, + STATE(1453), 1, + sym__block_if_else_folded, + STATE(1336), 2, + sym__annotation, + sym_block_comment, + [72241] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1543), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1337), 2, + sym__annotation, + sym_block_comment, + [72262] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2326), 1, + anon_sym_LPAREN, + ACTIONS(2324), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1338), 2, + sym__annotation, + sym_block_comment, + [72283] = 6, + ACTIONS(2098), 1, + sym_annotation_start, + ACTIONS(2102), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(2104), 1, + sym_line_comment, + ACTIONS(2328), 1, + anon_sym_RPAREN, + ACTIONS(2330), 1, + sym_annotation_elem, + STATE(1339), 3, + sym__annotation, + sym_block_comment, + aux_sym__annotation_repeat1, + [72304] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2333), 1, + anon_sym_end, + STATE(1458), 1, + sym_block_if_else, + STATE(1340), 2, + sym__annotation, + sym_block_comment, + [72327] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_export, + ACTIONS(2161), 1, + anon_sym_import, + ACTIONS(2335), 1, + anon_sym_data, + STATE(1341), 2, + sym__annotation, + sym_block_comment, + [72350] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2337), 1, + anon_sym_RPAREN, + STATE(1460), 1, + sym__block_if_else_folded, + STATE(1342), 2, + sym__annotation, + sym_block_comment, + [72373] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2341), 1, + anon_sym_LPAREN, + ACTIONS(2339), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1343), 2, + sym__annotation, + sym_block_comment, + [72394] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2343), 1, + anon_sym_RPAREN, + STATE(1463), 1, + sym__block_if_else_folded, + STATE(1344), 2, + sym__annotation, + sym_block_comment, + [72417] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1593), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1345), 2, + sym__annotation, + sym_block_comment, + [72438] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2345), 1, + anon_sym_RPAREN, + STATE(1591), 1, + sym__block_if_else_folded, + STATE(1346), 2, + sym__annotation, + sym_block_comment, + [72461] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2347), 1, + anon_sym_RPAREN, + STATE(1497), 1, + sym__block_if_else_folded, + STATE(1347), 2, + sym__annotation, + sym_block_comment, + [72484] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2349), 1, + anon_sym_RPAREN, + STATE(1560), 1, + sym__block_if_else_folded, + STATE(1348), 2, + sym__annotation, + sym_block_comment, + [72507] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2353), 1, + anon_sym_LPAREN, + ACTIONS(2351), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1349), 2, + sym__annotation, + sym_block_comment, + [72528] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2355), 1, + anon_sym_param, + ACTIONS(2357), 1, + anon_sym_result, + ACTIONS(2359), 1, + anon_sym_type, + STATE(1350), 2, + sym__annotation, + sym_block_comment, + [72551] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2363), 1, + anon_sym_LPAREN, + ACTIONS(2361), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1351), 2, + sym__annotation, + sym_block_comment, + [72572] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2367), 1, + anon_sym_LPAREN, + ACTIONS(2365), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1352), 2, + sym__annotation, + sym_block_comment, + [72593] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2371), 1, + anon_sym_LPAREN, + ACTIONS(2369), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1353), 2, + sym__annotation, + sym_block_comment, + [72614] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2373), 1, + anon_sym_RPAREN, + STATE(1613), 1, + sym__block_if_else_folded, + STATE(1354), 2, + sym__annotation, + sym_block_comment, + [72637] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2375), 1, + anon_sym_RPAREN, + STATE(1514), 1, + sym__block_if_else_folded, + STATE(1355), 2, + sym__annotation, + sym_block_comment, + [72660] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2377), 1, + anon_sym_end, + STATE(1584), 1, + sym_block_if_else, + STATE(1356), 2, + sym__annotation, + sym_block_comment, + [72683] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2381), 1, + anon_sym_LPAREN, + ACTIONS(2379), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1357), 2, + sym__annotation, + sym_block_comment, + [72704] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2383), 1, + anon_sym_LPAREN, + ACTIONS(2385), 2, + anon_sym_RPAREN, + sym_string, + STATE(1358), 2, + sym__annotation, + sym_block_comment, + [72725] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1424), 1, + anon_sym_RPAREN, + STATE(1401), 1, + aux_sym_data_repeat1, + STATE(1359), 2, + sym__annotation, + sym_block_comment, + [72748] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2389), 1, + anon_sym_LPAREN, + ACTIONS(2387), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1360), 2, + sym__annotation, + sym_block_comment, + [72769] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2393), 1, + anon_sym_LPAREN, + ACTIONS(2391), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1361), 2, + sym__annotation, + sym_block_comment, + [72790] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1424), 1, + anon_sym_RPAREN, + STATE(1300), 1, + aux_sym_data_repeat1, + STATE(1362), 2, + sym__annotation, + sym_block_comment, + [72813] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2397), 1, + anon_sym_LPAREN, + ACTIONS(2395), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1363), 2, + sym__annotation, + sym_block_comment, + [72834] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2399), 1, + anon_sym_RPAREN, + STATE(1528), 1, + sym__block_if_else_folded, + STATE(1364), 2, + sym__annotation, + sym_block_comment, + [72857] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2403), 1, + anon_sym_LPAREN, + ACTIONS(2401), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1365), 2, + sym__annotation, + sym_block_comment, + [72878] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2407), 1, + anon_sym_LPAREN, + ACTIONS(2405), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1366), 2, + sym__annotation, + sym_block_comment, + [72899] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2411), 1, + anon_sym_LPAREN, + ACTIONS(2409), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1367), 2, + sym__annotation, + sym_block_comment, + [72920] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2415), 1, + anon_sym_LPAREN, + ACTIONS(2413), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1368), 2, + sym__annotation, + sym_block_comment, + [72941] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(2417), 1, + anon_sym_RPAREN, + STATE(1300), 1, + aux_sym_data_repeat1, + STATE(1369), 2, + sym__annotation, + sym_block_comment, + [72964] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1337), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1370), 2, + sym__annotation, + sym_block_comment, + [72985] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2419), 1, + anon_sym_RPAREN, + STATE(1537), 1, + sym__block_if_else_folded, + STATE(1371), 2, + sym__annotation, + sym_block_comment, + [73008] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2423), 1, + anon_sym_LPAREN, + ACTIONS(2421), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1372), 2, + sym__annotation, + sym_block_comment, + [73029] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2425), 1, + anon_sym_RPAREN, + STATE(1542), 1, + sym__block_if_else_folded, + STATE(1373), 2, + sym__annotation, + sym_block_comment, + [73052] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2427), 1, + anon_sym_end, + STATE(1465), 1, + sym_block_if_else, + STATE(1374), 2, + sym__annotation, + sym_block_comment, + [73075] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2429), 1, + anon_sym_end, + STATE(1590), 1, + sym_block_if_else, + STATE(1375), 2, + sym__annotation, + sym_block_comment, + [73098] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2431), 1, + anon_sym_RPAREN, + STATE(1545), 1, + sym__block_if_else_folded, + STATE(1376), 2, + sym__annotation, + sym_block_comment, + [73121] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1558), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1377), 2, + sym__annotation, + sym_block_comment, + [73142] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1518), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1378), 2, + sym__annotation, + sym_block_comment, + [73163] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2433), 1, + anon_sym_RPAREN, + STATE(1607), 1, + sym__block_if_else_folded, + STATE(1379), 2, + sym__annotation, + sym_block_comment, + [73186] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2437), 1, + anon_sym_LPAREN, + ACTIONS(2435), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1380), 2, + sym__annotation, + sym_block_comment, + [73207] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1585), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1381), 2, + sym__annotation, + sym_block_comment, + [73228] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2439), 1, + anon_sym_end, + STATE(1474), 1, + sym_block_if_else, + STATE(1382), 2, + sym__annotation, + sym_block_comment, + [73251] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2443), 1, + anon_sym_LPAREN, + ACTIONS(2441), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1383), 2, + sym__annotation, + sym_block_comment, + [73272] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2447), 1, + anon_sym_LPAREN, + ACTIONS(2445), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1384), 2, + sym__annotation, + sym_block_comment, + [73293] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1486), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1385), 2, + sym__annotation, + sym_block_comment, + [73314] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2449), 1, + anon_sym_RPAREN, + STATE(1603), 1, + sym_mem_page_size, + STATE(1386), 2, + sym__annotation, + sym_block_comment, + [73337] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2453), 1, + anon_sym_LPAREN, + ACTIONS(2451), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1387), 2, + sym__annotation, + sym_block_comment, + [73358] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2457), 1, + anon_sym_LPAREN, + ACTIONS(2455), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1388), 2, + sym__annotation, + sym_block_comment, + [73379] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(2459), 1, + anon_sym_RPAREN, + STATE(1369), 1, + aux_sym_data_repeat1, + STATE(1389), 2, + sym__annotation, + sym_block_comment, + [73402] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1634), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1390), 2, + sym__annotation, + sym_block_comment, + [73423] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(2461), 1, + anon_sym_RPAREN, + STATE(1300), 1, + aux_sym_data_repeat1, + STATE(1391), 2, + sym__annotation, + sym_block_comment, + [73446] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2465), 1, + anon_sym_LPAREN, + ACTIONS(2463), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1392), 2, + sym__annotation, + sym_block_comment, + [73467] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(2459), 1, + anon_sym_RPAREN, + STATE(1300), 1, + aux_sym_data_repeat1, + STATE(1393), 2, + sym__annotation, + sym_block_comment, + [73490] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2469), 1, + anon_sym_LPAREN, + ACTIONS(2467), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1394), 2, + sym__annotation, + sym_block_comment, + [73511] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1434), 1, + anon_sym_RPAREN, + STATE(1393), 1, + aux_sym_data_repeat1, + STATE(1395), 2, + sym__annotation, + sym_block_comment, + [73534] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2473), 1, + anon_sym_LPAREN, + ACTIONS(2471), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1396), 2, + sym__annotation, + sym_block_comment, + [73555] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2475), 1, + anon_sym_RPAREN, + STATE(1459), 1, + sym__block_if_else_folded, + STATE(1397), 2, + sym__annotation, + sym_block_comment, + [73578] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1539), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1398), 2, + sym__annotation, + sym_block_comment, + [73599] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2479), 1, + anon_sym_LPAREN, + ACTIONS(2477), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1399), 2, + sym__annotation, + sym_block_comment, + [73620] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2481), 1, + anon_sym_RPAREN, + STATE(1625), 1, + sym__block_if_else_folded, + STATE(1400), 2, + sym__annotation, + sym_block_comment, + [73643] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(1434), 1, + anon_sym_RPAREN, + STATE(1300), 1, + aux_sym_data_repeat1, + STATE(1401), 2, + sym__annotation, + sym_block_comment, + [73666] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2485), 1, + anon_sym_LPAREN, + ACTIONS(2483), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1402), 2, + sym__annotation, + sym_block_comment, + [73687] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2197), 1, + anon_sym_LPAREN, + ACTIONS(2487), 1, + anon_sym_RPAREN, + STATE(1469), 1, + sym__block_if_else_folded, + STATE(1403), 2, + sym__annotation, + sym_block_comment, + [73710] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2017), 1, + anon_sym_LPAREN, + ACTIONS(2489), 1, + anon_sym_RPAREN, + STATE(1480), 1, + sym_mem_page_size, + STATE(1404), 2, + sym__annotation, + sym_block_comment, + [73733] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1452), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1405), 2, + sym__annotation, + sym_block_comment, + [73754] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2493), 1, + anon_sym_LPAREN, + ACTIONS(2491), 2, + ts_builtin_sym_end, + anon_sym_RPAREN, + STATE(1406), 2, + sym__annotation, + sym_block_comment, + [73775] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2195), 1, + anon_sym_else, + ACTIONS(2495), 1, + anon_sym_end, + STATE(1576), 1, + sym_block_if_else, + STATE(1407), 2, + sym__annotation, + sym_block_comment, + [73798] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_export, + ACTIONS(2161), 1, + anon_sym_import, + ACTIONS(2163), 1, + anon_sym_ref, + STATE(1408), 2, + sym__annotation, + sym_block_comment, + [73821] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1385), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1409), 2, + sym__annotation, + sym_block_comment, + [73842] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1248), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1410), 2, + sym__annotation, + sym_block_comment, + [73863] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1284), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1411), 2, + sym__annotation, + sym_block_comment, + [73884] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + STATE(1286), 1, + sym_index, + ACTIONS(341), 2, + sym_identifier, + sym_uinteger, + STATE(1412), 2, + sym__annotation, + sym_block_comment, + [73905] = 7, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1352), 1, + sym_string, + ACTIONS(2497), 1, + anon_sym_RPAREN, + STATE(1391), 1, + aux_sym_data_repeat1, + STATE(1413), 2, + sym__annotation, + sym_block_comment, + [73928] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2499), 1, + anon_sym_LPAREN, + ACTIONS(2501), 1, + anon_sym_RPAREN, + STATE(1414), 2, + sym__annotation, + sym_block_comment, + [73948] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2503), 1, + anon_sym_LPAREN, + STATE(1606), 1, + sym_extern_idx, + STATE(1415), 2, + sym__annotation, + sym_block_comment, + [73968] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2151), 1, + anon_sym_param, + ACTIONS(2153), 1, + anon_sym_type, + STATE(1416), 2, + sym__annotation, + sym_block_comment, + [73988] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2505), 1, + anon_sym_LPAREN, + STATE(1588), 1, + sym_elem, + STATE(1417), 2, + sym__annotation, + sym_block_comment, + [74008] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2507), 1, + anon_sym_LPAREN, + ACTIONS(2509), 1, + anon_sym_RPAREN, + STATE(1418), 2, + sym__annotation, + sym_block_comment, + [74028] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2505), 1, + anon_sym_LPAREN, + STATE(1554), 1, + sym_elem, + STATE(1419), 2, + sym__annotation, + sym_block_comment, + [74048] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2511), 1, + anon_sym_LPAREN, + ACTIONS(2513), 1, + anon_sym_RPAREN, + STATE(1420), 2, + sym__annotation, + sym_block_comment, + [74068] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2515), 1, + anon_sym_LPAREN, + ACTIONS(2517), 1, + anon_sym_RPAREN, + STATE(1421), 2, + sym__annotation, + sym_block_comment, + [74088] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2519), 1, + anon_sym_LPAREN, + ACTIONS(2521), 1, + anon_sym_RPAREN, + STATE(1422), 2, + sym__annotation, + sym_block_comment, + [74108] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2523), 1, + anon_sym_on, + ACTIONS(2525), 1, + anon_sym_ref, + STATE(1423), 2, + sym__annotation, + sym_block_comment, + [74128] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2159), 1, + anon_sym_mut, + ACTIONS(2163), 1, + anon_sym_ref, + STATE(1424), 2, + sym__annotation, + sym_block_comment, + [74148] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2527), 1, + ts_builtin_sym_end, + ACTIONS(2529), 1, + anon_sym_LPAREN, + STATE(1425), 2, + sym__annotation, + sym_block_comment, + [74168] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2531), 1, + ts_builtin_sym_end, + ACTIONS(2533), 1, + anon_sym_LPAREN, + STATE(1426), 2, + sym__annotation, + sym_block_comment, + [74188] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2151), 1, + anon_sym_param, + ACTIONS(2268), 1, + anon_sym_result, + STATE(1427), 2, + sym__annotation, + sym_block_comment, + [74208] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2535), 1, + ts_builtin_sym_end, + ACTIONS(2537), 1, + anon_sym_LPAREN, + STATE(1428), 2, + sym__annotation, + sym_block_comment, + [74228] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2539), 1, + anon_sym_LPAREN, + ACTIONS(2541), 1, + anon_sym_RPAREN, + STATE(1429), 2, + sym__annotation, + sym_block_comment, + [74248] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2543), 1, + ts_builtin_sym_end, + ACTIONS(2545), 1, + anon_sym_LPAREN, + STATE(1430), 2, + sym__annotation, + sym_block_comment, + [74268] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2547), 1, + anon_sym_LPAREN, + ACTIONS(2549), 1, + anon_sym_RPAREN, + STATE(1431), 2, + sym__annotation, + sym_block_comment, + [74288] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2187), 1, + anon_sym_param, + ACTIONS(2189), 1, + anon_sym_result, + STATE(1432), 2, + sym__annotation, + sym_block_comment, + [74308] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2551), 1, + anon_sym_LPAREN, + ACTIONS(2553), 1, + anon_sym_RPAREN, + STATE(1433), 2, + sym__annotation, + sym_block_comment, + [74328] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2355), 1, + anon_sym_param, + ACTIONS(2357), 1, + anon_sym_result, + STATE(1434), 2, + sym__annotation, + sym_block_comment, + [74348] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2555), 1, + anon_sym_LPAREN, + ACTIONS(2557), 1, + anon_sym_RPAREN, + STATE(1435), 2, + sym__annotation, + sym_block_comment, + [74368] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2505), 1, + anon_sym_LPAREN, + STATE(1503), 1, + sym_elem, + STATE(1436), 2, + sym__annotation, + sym_block_comment, + [74388] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2559), 1, + anon_sym_LPAREN, + ACTIONS(2561), 1, + anon_sym_RPAREN, + STATE(1437), 2, + sym__annotation, + sym_block_comment, + [74408] = 6, + ACTIONS(2098), 1, + sym_annotation_start, + ACTIONS(2102), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(2104), 1, + sym_line_comment, + ACTIONS(2563), 1, + anon_sym_RPAREN, + ACTIONS(2565), 1, + sym_annotation_elem, + STATE(1438), 2, + sym__annotation, + sym_block_comment, + [74428] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2505), 1, + anon_sym_LPAREN, + STATE(1580), 1, + sym_elem, + STATE(1439), 2, + sym__annotation, + sym_block_comment, + [74448] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2567), 1, + anon_sym_SEMI_RPAREN, + ACTIONS(2569), 1, + sym__block_comment_content, + STATE(1440), 2, + sym__annotation, + sym_block_comment, + [74468] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2571), 1, + anon_sym_LPAREN, + ACTIONS(2573), 1, + anon_sym_RPAREN, + STATE(1441), 2, + sym__annotation, + sym_block_comment, + [74488] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2575), 1, + anon_sym_on, + ACTIONS(2577), 1, + anon_sym_ref, + STATE(1442), 2, + sym__annotation, + sym_block_comment, + [74508] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2163), 1, + anon_sym_ref, + ACTIONS(2579), 1, + anon_sym_mut, + STATE(1443), 2, + sym__annotation, + sym_block_comment, + [74528] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2579), 1, + anon_sym_mut, + ACTIONS(2581), 1, + anon_sym_ref, + STATE(1444), 2, + sym__annotation, + sym_block_comment, + [74548] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2583), 1, + anon_sym_on, + ACTIONS(2585), 1, + anon_sym_ref, + STATE(1445), 2, + sym__annotation, + sym_block_comment, + [74568] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2587), 2, + anon_sym_RPAREN, + sym_string, + STATE(1446), 2, + sym__annotation, + sym_block_comment, + [74586] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2589), 1, + anon_sym_on, + ACTIONS(2591), 1, + anon_sym_ref, + STATE(1447), 2, + sym__annotation, + sym_block_comment, + [74606] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2593), 1, + anon_sym_LPAREN, + ACTIONS(2595), 1, + anon_sym_RPAREN, + STATE(1448), 2, + sym__annotation, + sym_block_comment, + [74626] = 6, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2597), 1, + anon_sym_LPAREN, + ACTIONS(2599), 1, + anon_sym_RPAREN, + STATE(1449), 2, + sym__annotation, + sym_block_comment, + [74646] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2601), 1, + anon_sym_RPAREN, + STATE(1450), 2, + sym__annotation, + sym_block_comment, + [74663] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2603), 1, + anon_sym_RPAREN, + STATE(1451), 2, + sym__annotation, + sym_block_comment, + [74680] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2605), 1, + anon_sym_RPAREN, + STATE(1452), 2, + sym__annotation, + sym_block_comment, + [74697] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2337), 1, + anon_sym_RPAREN, + STATE(1453), 2, + sym__annotation, + sym_block_comment, + [74714] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2217), 1, + anon_sym_RPAREN, + STATE(1454), 2, + sym__annotation, + sym_block_comment, + [74731] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2607), 1, + anon_sym_RPAREN, + STATE(1455), 2, + sym__annotation, + sym_block_comment, + [74748] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2609), 1, + anon_sym_RPAREN, + STATE(1456), 2, + sym__annotation, + sym_block_comment, + [74765] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2611), 1, + anon_sym_RPAREN, + STATE(1457), 2, + sym__annotation, + sym_block_comment, + [74782] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2613), 1, + anon_sym_end, + STATE(1458), 2, + sym__annotation, + sym_block_comment, + [74799] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2246), 1, + anon_sym_RPAREN, + STATE(1459), 2, + sym__annotation, + sym_block_comment, + [74816] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2343), 1, + anon_sym_RPAREN, + STATE(1460), 2, + sym__annotation, + sym_block_comment, + [74833] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2615), 1, + anon_sym_RPAREN, + STATE(1461), 2, + sym__annotation, + sym_block_comment, + [74850] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2355), 1, + anon_sym_param, + STATE(1462), 2, + sym__annotation, + sym_block_comment, + [74867] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2617), 1, + anon_sym_RPAREN, + STATE(1463), 2, + sym__annotation, + sym_block_comment, + [74884] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2147), 1, + anon_sym_export, + STATE(1464), 2, + sym__annotation, + sym_block_comment, + [74901] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2228), 1, + anon_sym_end, + STATE(1465), 2, + sym__annotation, + sym_block_comment, + [74918] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2619), 1, + anon_sym_RPAREN, + STATE(1466), 2, + sym__annotation, + sym_block_comment, + [74935] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2621), 1, + anon_sym_RPAREN, + STATE(1467), 2, + sym__annotation, + sym_block_comment, + [74952] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2623), 1, + anon_sym_RPAREN, + STATE(1468), 2, + sym__annotation, + sym_block_comment, + [74969] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2475), 1, + anon_sym_RPAREN, + STATE(1469), 2, + sym__annotation, + sym_block_comment, + [74986] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2335), 1, + anon_sym_data, + STATE(1470), 2, + sym__annotation, + sym_block_comment, + [75003] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2625), 1, + anon_sym_RPAREN, + STATE(1471), 2, + sym__annotation, + sym_block_comment, + [75020] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2427), 1, + anon_sym_end, + STATE(1472), 2, + sym__annotation, + sym_block_comment, + [75037] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2349), 1, + anon_sym_RPAREN, + STATE(1473), 2, + sym__annotation, + sym_block_comment, + [75054] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2495), 1, + anon_sym_end, + STATE(1474), 2, + sym__annotation, + sym_block_comment, + [75071] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2627), 1, + anon_sym_RPAREN, + STATE(1475), 2, + sym__annotation, + sym_block_comment, + [75088] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2629), 1, + sym_string, + STATE(1476), 2, + sym__annotation, + sym_block_comment, + [75105] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2631), 1, + sym_string, + STATE(1477), 2, + sym__annotation, + sym_block_comment, + [75122] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2633), 1, + anon_sym_RPAREN, + STATE(1478), 2, + sym__annotation, + sym_block_comment, + [75139] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2635), 1, + ts_builtin_sym_end, + STATE(1479), 2, + sym__annotation, + sym_block_comment, + [75156] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2637), 1, + anon_sym_RPAREN, + STATE(1480), 2, + sym__annotation, + sym_block_comment, + [75173] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2639), 1, + anon_sym_RPAREN, + STATE(1481), 2, + sym__annotation, + sym_block_comment, + [75190] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1400), 1, + anon_sym_type, + STATE(1482), 2, + sym__annotation, + sym_block_comment, + [75207] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2151), 1, + anon_sym_param, + STATE(1483), 2, + sym__annotation, + sym_block_comment, + [75224] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2449), 1, + anon_sym_RPAREN, + STATE(1484), 2, + sym__annotation, + sym_block_comment, + [75241] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2252), 1, + anon_sym_end, + STATE(1485), 2, + sym__annotation, + sym_block_comment, + [75258] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2641), 1, + anon_sym_RPAREN, + STATE(1486), 2, + sym__annotation, + sym_block_comment, + [75275] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2643), 1, + anon_sym_RPAREN, + STATE(1487), 2, + sym__annotation, + sym_block_comment, + [75292] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2357), 1, + anon_sym_result, + STATE(1488), 2, + sym__annotation, + sym_block_comment, + [75309] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2189), 1, + anon_sym_result, + STATE(1489), 2, + sym__annotation, + sym_block_comment, + [75326] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2645), 1, + anon_sym_end, + STATE(1490), 2, + sym__annotation, + sym_block_comment, + [75343] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2647), 1, + anon_sym_RPAREN, + STATE(1491), 2, + sym__annotation, + sym_block_comment, + [75360] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2649), 1, + anon_sym_RPAREN, + STATE(1492), 2, + sym__annotation, + sym_block_comment, + [75377] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2651), 1, + anon_sym_RPAREN, + STATE(1493), 2, + sym__annotation, + sym_block_comment, + [75394] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1394), 1, + anon_sym_module, + STATE(1494), 2, + sym__annotation, + sym_block_comment, + [75411] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2373), 1, + anon_sym_RPAREN, + STATE(1495), 2, + sym__annotation, + sym_block_comment, + [75428] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2653), 1, + anon_sym_RPAREN, + STATE(1496), 2, + sym__annotation, + sym_block_comment, + [75445] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2375), 1, + anon_sym_RPAREN, + STATE(1497), 2, + sym__annotation, + sym_block_comment, + [75462] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2377), 1, + anon_sym_end, + STATE(1498), 2, + sym__annotation, + sym_block_comment, + [75479] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2258), 1, + anon_sym_RPAREN, + STATE(1499), 2, + sym__annotation, + sym_block_comment, + [75496] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2655), 1, + anon_sym_RPAREN, + STATE(1500), 2, + sym__annotation, + sym_block_comment, + [75513] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2276), 1, + anon_sym_RPAREN, + STATE(1501), 2, + sym__annotation, + sym_block_comment, + [75530] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2657), 1, + anon_sym_RPAREN, + STATE(1502), 2, + sym__annotation, + sym_block_comment, + [75547] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(996), 1, + anon_sym_RPAREN, + STATE(1503), 2, + sym__annotation, + sym_block_comment, + [75564] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2268), 1, + anon_sym_result, + STATE(1504), 2, + sym__annotation, + sym_block_comment, + [75581] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2659), 1, + sym_uinteger, + STATE(1505), 2, + sym__annotation, + sym_block_comment, + [75598] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2661), 1, + anon_sym_RPAREN, + STATE(1506), 2, + sym__annotation, + sym_block_comment, + [75615] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2663), 1, + anon_sym_RPAREN, + STATE(1507), 2, + sym__annotation, + sym_block_comment, + [75632] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2665), 1, + anon_sym_RPAREN, + STATE(1508), 2, + sym__annotation, + sym_block_comment, + [75649] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2667), 1, + anon_sym_RPAREN, + STATE(1509), 2, + sym__annotation, + sym_block_comment, + [75666] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2669), 1, + anon_sym_RPAREN, + STATE(1510), 2, + sym__annotation, + sym_block_comment, + [75683] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2671), 1, + anon_sym_RPAREN, + STATE(1511), 2, + sym__annotation, + sym_block_comment, + [75700] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2429), 1, + anon_sym_end, + STATE(1512), 2, + sym__annotation, + sym_block_comment, + [75717] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2262), 1, + anon_sym_end, + STATE(1513), 2, + sym__annotation, + sym_block_comment, + [75734] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2399), 1, + anon_sym_RPAREN, + STATE(1514), 2, + sym__annotation, + sym_block_comment, + [75751] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2673), 1, + anon_sym_RPAREN, + STATE(1515), 2, + sym__annotation, + sym_block_comment, + [75768] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2187), 1, + anon_sym_param, + STATE(1516), 2, + sym__annotation, + sym_block_comment, + [75785] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2675), 1, + anon_sym_elem, + STATE(1517), 2, + sym__annotation, + sym_block_comment, + [75802] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2677), 1, + anon_sym_RPAREN, + STATE(1518), 2, + sym__annotation, + sym_block_comment, + [75819] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2679), 1, + anon_sym_RPAREN, + STATE(1519), 2, + sym__annotation, + sym_block_comment, + [75836] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2681), 1, + anon_sym_RPAREN, + STATE(1520), 2, + sym__annotation, + sym_block_comment, + [75853] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2683), 1, + anon_sym_RPAREN, + STATE(1521), 2, + sym__annotation, + sym_block_comment, + [75870] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2685), 1, + anon_sym_LPAREN, + STATE(1522), 2, + sym__annotation, + sym_block_comment, + [75887] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2687), 1, + anon_sym_RPAREN, + STATE(1523), 2, + sym__annotation, + sym_block_comment, + [75904] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2689), 1, + anon_sym_RPAREN, + STATE(1524), 2, + sym__annotation, + sym_block_comment, + [75921] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2691), 1, + anon_sym_RPAREN, + STATE(1525), 2, + sym__annotation, + sym_block_comment, + [75938] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2693), 1, + anon_sym_RPAREN, + STATE(1526), 2, + sym__annotation, + sym_block_comment, + [75955] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2695), 1, + anon_sym_RPAREN, + STATE(1527), 2, + sym__annotation, + sym_block_comment, + [75972] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2419), 1, + anon_sym_RPAREN, + STATE(1528), 2, + sym__annotation, + sym_block_comment, + [75989] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2697), 1, + anon_sym_RPAREN, + STATE(1529), 2, + sym__annotation, + sym_block_comment, + [76006] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2699), 1, + anon_sym_RPAREN, + STATE(1530), 2, + sym__annotation, + sym_block_comment, + [76023] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2701), 1, + anon_sym_RPAREN, + STATE(1531), 2, + sym__annotation, + sym_block_comment, + [76040] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2703), 1, + anon_sym_RPAREN, + STATE(1532), 2, + sym__annotation, + sym_block_comment, + [76057] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2705), 1, + anon_sym_RPAREN, + STATE(1533), 2, + sym__annotation, + sym_block_comment, + [76074] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2707), 1, + anon_sym_RPAREN, + STATE(1534), 2, + sym__annotation, + sym_block_comment, + [76091] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2709), 1, + sym_string, + STATE(1535), 2, + sym__annotation, + sym_block_comment, + [76108] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2711), 1, + anon_sym_RPAREN, + STATE(1536), 2, + sym__annotation, + sym_block_comment, + [76125] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2425), 1, + anon_sym_RPAREN, + STATE(1537), 2, + sym__annotation, + sym_block_comment, + [76142] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2274), 1, + anon_sym_end, + STATE(1538), 2, + sym__annotation, + sym_block_comment, + [76159] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2713), 1, + anon_sym_RPAREN, + STATE(1539), 2, + sym__annotation, + sym_block_comment, + [76176] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2715), 1, + sym_uinteger, + STATE(1540), 2, + sym__annotation, + sym_block_comment, + [76193] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2717), 1, + anon_sym_RPAREN, + STATE(1541), 2, + sym__annotation, + sym_block_comment, + [76210] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2431), 1, + anon_sym_RPAREN, + STATE(1542), 2, + sym__annotation, + sym_block_comment, + [76227] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2719), 1, + anon_sym_RPAREN, + STATE(1543), 2, + sym__annotation, + sym_block_comment, + [76244] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2163), 1, + anon_sym_ref, + STATE(1544), 2, + sym__annotation, + sym_block_comment, + [76261] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2721), 1, + anon_sym_RPAREN, + STATE(1545), 2, + sym__annotation, + sym_block_comment, + [76278] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2723), 1, + anon_sym_RPAREN, + STATE(1546), 2, + sym__annotation, + sym_block_comment, + [76295] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2725), 1, + anon_sym_RPAREN, + STATE(1547), 2, + sym__annotation, + sym_block_comment, + [76312] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2727), 1, + anon_sym_RPAREN, + STATE(1548), 2, + sym__annotation, + sym_block_comment, + [76329] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2729), 1, + anon_sym_RPAREN, + STATE(1549), 2, + sym__annotation, + sym_block_comment, + [76346] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2731), 1, + anon_sym_else, + STATE(1550), 2, + sym__annotation, + sym_block_comment, + [76363] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2733), 1, + anon_sym_RPAREN, + STATE(1551), 2, + sym__annotation, + sym_block_comment, + [76380] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2581), 1, + anon_sym_ref, + STATE(1552), 2, + sym__annotation, + sym_block_comment, + [76397] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2735), 1, + sym_string, + STATE(1553), 2, + sym__annotation, + sym_block_comment, + [76414] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(930), 1, + anon_sym_RPAREN, + STATE(1554), 2, + sym__annotation, + sym_block_comment, + [76431] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2737), 1, + anon_sym_RPAREN, + STATE(1555), 2, + sym__annotation, + sym_block_comment, + [76448] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2739), 1, + anon_sym_RPAREN, + STATE(1556), 2, + sym__annotation, + sym_block_comment, + [76465] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2741), 1, + anon_sym_RPAREN, + STATE(1557), 2, + sym__annotation, + sym_block_comment, + [76482] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2743), 1, + anon_sym_RPAREN, + STATE(1558), 2, + sym__annotation, + sym_block_comment, + [76499] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2745), 1, + sym_string, + STATE(1559), 2, + sym__annotation, + sym_block_comment, + [76516] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2433), 1, + anon_sym_RPAREN, + STATE(1560), 2, + sym__annotation, + sym_block_comment, + [76533] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(998), 1, + anon_sym_RPAREN, + STATE(1561), 2, + sym__annotation, + sym_block_comment, + [76550] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2747), 1, + anon_sym_local, + STATE(1562), 2, + sym__annotation, + sym_block_comment, + [76567] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2749), 1, + sym_string, + STATE(1563), 2, + sym__annotation, + sym_block_comment, + [76584] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2751), 1, + anon_sym_RPAREN, + STATE(1564), 2, + sym__annotation, + sym_block_comment, + [76601] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2753), 1, + anon_sym_RPAREN, + STATE(1565), 2, + sym__annotation, + sym_block_comment, + [76618] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2755), 1, + anon_sym_RPAREN, + STATE(1566), 2, + sym__annotation, + sym_block_comment, + [76635] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2286), 1, + anon_sym_end, + STATE(1567), 2, + sym__annotation, + sym_block_comment, + [76652] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2439), 1, + anon_sym_end, + STATE(1568), 2, + sym__annotation, + sym_block_comment, + [76669] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_export, + STATE(1569), 2, + sym__annotation, + sym_block_comment, + [76686] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2757), 1, + anon_sym_RPAREN, + STATE(1570), 2, + sym__annotation, + sym_block_comment, + [76703] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2759), 1, + anon_sym_RPAREN, + STATE(1571), 2, + sym__annotation, + sym_block_comment, + [76720] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2761), 1, + anon_sym_SEMI_RPAREN, + STATE(1572), 2, + sym__annotation, + sym_block_comment, + [76737] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2763), 1, + anon_sym_RPAREN, + STATE(1573), 2, + sym__annotation, + sym_block_comment, + [76754] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2288), 1, + anon_sym_RPAREN, + STATE(1574), 2, + sym__annotation, + sym_block_comment, + [76771] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2765), 1, + anon_sym_RPAREN, + STATE(1575), 2, + sym__annotation, + sym_block_comment, + [76788] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2193), 1, + anon_sym_end, + STATE(1576), 2, + sym__annotation, + sym_block_comment, + [76805] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2767), 1, + anon_sym_RPAREN, + STATE(1577), 2, + sym__annotation, + sym_block_comment, + [76822] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2769), 1, + anon_sym_RPAREN, + STATE(1578), 2, + sym__annotation, + sym_block_comment, + [76839] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2771), 1, + sym_uinteger, + STATE(1579), 2, + sym__annotation, + sym_block_comment, + [76856] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(910), 1, + anon_sym_RPAREN, + STATE(1580), 2, + sym__annotation, + sym_block_comment, + [76873] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2773), 1, + sym_string, + STATE(1581), 2, + sym__annotation, + sym_block_comment, + [76890] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2775), 1, + anon_sym_RPAREN, + STATE(1582), 2, + sym__annotation, + sym_block_comment, + [76907] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2777), 1, + anon_sym_RPAREN, + STATE(1583), 2, + sym__annotation, + sym_block_comment, + [76924] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2779), 1, + anon_sym_end, + STATE(1584), 2, + sym__annotation, + sym_block_comment, + [76941] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2781), 1, + anon_sym_RPAREN, + STATE(1585), 2, + sym__annotation, + sym_block_comment, + [76958] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2783), 1, + anon_sym_RPAREN, + STATE(1586), 2, + sym__annotation, + sym_block_comment, + [76975] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2785), 1, + anon_sym_RPAREN, + STATE(1587), 2, + sym__annotation, + sym_block_comment, + [76992] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(942), 1, + anon_sym_RPAREN, + STATE(1588), 2, + sym__annotation, + sym_block_comment, + [77009] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2787), 1, + anon_sym_RPAREN, + STATE(1589), 2, + sym__annotation, + sym_block_comment, + [77026] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2209), 1, + anon_sym_end, + STATE(1590), 2, + sym__annotation, + sym_block_comment, + [77043] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2260), 1, + anon_sym_RPAREN, + STATE(1591), 2, + sym__annotation, + sym_block_comment, + [77060] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2789), 1, + anon_sym_RPAREN, + STATE(1592), 2, + sym__annotation, + sym_block_comment, + [77077] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2791), 1, + anon_sym_RPAREN, + STATE(1593), 2, + sym__annotation, + sym_block_comment, + [77094] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2793), 1, + anon_sym_field, + STATE(1594), 2, + sym__annotation, + sym_block_comment, + [77111] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2795), 1, + anon_sym_RPAREN, + STATE(1595), 2, + sym__annotation, + sym_block_comment, + [77128] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2310), 1, + anon_sym_end, + STATE(1596), 2, + sym__annotation, + sym_block_comment, + [77145] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2797), 1, + anon_sym_RPAREN, + STATE(1597), 2, + sym__annotation, + sym_block_comment, + [77162] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2799), 1, + anon_sym_RPAREN, + STATE(1598), 2, + sym__annotation, + sym_block_comment, + [77179] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2801), 1, + anon_sym_RPAREN, + STATE(1599), 2, + sym__annotation, + sym_block_comment, + [77196] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2803), 1, + anon_sym_RPAREN, + STATE(1600), 2, + sym__annotation, + sym_block_comment, + [77213] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2805), 1, + anon_sym_RPAREN, + STATE(1601), 2, + sym__annotation, + sym_block_comment, + [77230] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2807), 1, + anon_sym_RPAREN, + STATE(1602), 2, + sym__annotation, + sym_block_comment, + [77247] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2809), 1, + anon_sym_RPAREN, + STATE(1603), 2, + sym__annotation, + sym_block_comment, + [77264] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2211), 1, + anon_sym_RPAREN, + STATE(1604), 2, + sym__annotation, + sym_block_comment, + [77281] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2811), 1, + anon_sym_RPAREN, + STATE(1605), 2, + sym__annotation, + sym_block_comment, + [77298] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2813), 1, + anon_sym_RPAREN, + STATE(1606), 2, + sym__annotation, + sym_block_comment, + [77315] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2481), 1, + anon_sym_RPAREN, + STATE(1607), 2, + sym__annotation, + sym_block_comment, + [77332] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2815), 1, + anon_sym_RPAREN, + STATE(1608), 2, + sym__annotation, + sym_block_comment, + [77349] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(928), 1, + anon_sym_RPAREN, + STATE(1609), 2, + sym__annotation, + sym_block_comment, + [77366] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(1038), 1, + anon_sym_RPAREN, + STATE(1610), 2, + sym__annotation, + sym_block_comment, + [77383] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2817), 1, + anon_sym_RPAREN, + STATE(1611), 2, + sym__annotation, + sym_block_comment, + [77400] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2819), 1, + anon_sym_RPAREN, + STATE(1612), 2, + sym__annotation, + sym_block_comment, + [77417] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2487), 1, + anon_sym_RPAREN, + STATE(1613), 2, + sym__annotation, + sym_block_comment, + [77434] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2821), 1, + anon_sym_RPAREN, + STATE(1614), 2, + sym__annotation, + sym_block_comment, + [77451] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2823), 1, + sym_uinteger, + STATE(1615), 2, + sym__annotation, + sym_block_comment, + [77468] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2489), 1, + anon_sym_RPAREN, + STATE(1616), 2, + sym__annotation, + sym_block_comment, + [77485] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2825), 1, + anon_sym_RPAREN, + STATE(1617), 2, + sym__annotation, + sym_block_comment, + [77502] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2322), 1, + anon_sym_RPAREN, + STATE(1618), 2, + sym__annotation, + sym_block_comment, + [77519] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2827), 1, + anon_sym_RPAREN, + STATE(1619), 2, + sym__annotation, + sym_block_comment, + [77536] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2829), 1, + anon_sym_RPAREN, + STATE(1620), 2, + sym__annotation, + sym_block_comment, + [77553] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2831), 1, + anon_sym_RPAREN, + STATE(1621), 2, + sym__annotation, + sym_block_comment, + [77570] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2833), 1, + anon_sym_RPAREN, + STATE(1622), 2, + sym__annotation, + sym_block_comment, + [77587] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2835), 1, + anon_sym_RPAREN, + STATE(1623), 2, + sym__annotation, + sym_block_comment, + [77604] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2837), 1, + anon_sym_RPAREN, + STATE(1624), 2, + sym__annotation, + sym_block_comment, + [77621] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2839), 1, + anon_sym_RPAREN, + STATE(1625), 2, + sym__annotation, + sym_block_comment, + [77638] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2841), 1, + sym_string, + STATE(1626), 2, + sym__annotation, + sym_block_comment, + [77655] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2843), 1, + anon_sym_pagesize, + STATE(1627), 2, + sym__annotation, + sym_block_comment, + [77672] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2320), 1, + anon_sym_end, + STATE(1628), 2, + sym__annotation, + sym_block_comment, + [77689] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2845), 1, + sym_string, + STATE(1629), 2, + sym__annotation, + sym_block_comment, + [77706] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2847), 1, + anon_sym_RPAREN, + STATE(1630), 2, + sym__annotation, + sym_block_comment, + [77723] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2849), 1, + anon_sym_RPAREN, + STATE(1631), 2, + sym__annotation, + sym_block_comment, + [77740] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2201), 1, + anon_sym_RPAREN, + STATE(1632), 2, + sym__annotation, + sym_block_comment, + [77757] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2333), 1, + anon_sym_end, + STATE(1633), 2, + sym__annotation, + sym_block_comment, + [77774] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2851), 1, + anon_sym_RPAREN, + STATE(1634), 2, + sym__annotation, + sym_block_comment, + [77791] = 5, + ACTIONS(3), 1, + sym_annotation_start, + ACTIONS(5), 1, + anon_sym_LPAREN_SEMI, + ACTIONS(7), 1, + sym_line_comment, + ACTIONS(2853), 1, + anon_sym_RPAREN, + STATE(1635), 2, + sym__annotation, + sym_block_comment, + [77808] = 1, + ACTIONS(2855), 1, + ts_builtin_sym_end, + [77812] = 1, + ACTIONS(2857), 1, + ts_builtin_sym_end, + [77816] = 1, + ACTIONS(2859), 1, + ts_builtin_sym_end, + [77820] = 1, + ACTIONS(2861), 1, + ts_builtin_sym_end, + [77824] = 1, + ACTIONS(2863), 1, + ts_builtin_sym_end, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 117, + [SMALL_STATE(4)] = 220, + [SMALL_STATE(5)] = 337, + [SMALL_STATE(6)] = 440, + [SMALL_STATE(7)] = 557, + [SMALL_STATE(8)] = 674, + [SMALL_STATE(9)] = 791, + [SMALL_STATE(10)] = 892, + [SMALL_STATE(11)] = 1009, + [SMALL_STATE(12)] = 1126, + [SMALL_STATE(13)] = 1243, + [SMALL_STATE(14)] = 1345, + [SMALL_STATE(15)] = 1447, + [SMALL_STATE(16)] = 1551, + [SMALL_STATE(17)] = 1653, + [SMALL_STATE(18)] = 1753, + [SMALL_STATE(19)] = 1857, + [SMALL_STATE(20)] = 1950, + [SMALL_STATE(21)] = 2019, + [SMALL_STATE(22)] = 2088, + [SMALL_STATE(23)] = 2157, + [SMALL_STATE(24)] = 2226, + [SMALL_STATE(25)] = 2295, + [SMALL_STATE(26)] = 2364, + [SMALL_STATE(27)] = 2433, + [SMALL_STATE(28)] = 2502, + [SMALL_STATE(29)] = 2571, + [SMALL_STATE(30)] = 2640, + [SMALL_STATE(31)] = 2709, + [SMALL_STATE(32)] = 2777, + [SMALL_STATE(33)] = 2845, + [SMALL_STATE(34)] = 2913, + [SMALL_STATE(35)] = 2981, + [SMALL_STATE(36)] = 3049, + [SMALL_STATE(37)] = 3117, + [SMALL_STATE(38)] = 3185, + [SMALL_STATE(39)] = 3253, + [SMALL_STATE(40)] = 3321, + [SMALL_STATE(41)] = 3389, + [SMALL_STATE(42)] = 3457, + [SMALL_STATE(43)] = 3525, + [SMALL_STATE(44)] = 3593, + [SMALL_STATE(45)] = 3661, + [SMALL_STATE(46)] = 3729, + [SMALL_STATE(47)] = 3797, + [SMALL_STATE(48)] = 3865, + [SMALL_STATE(49)] = 3933, + [SMALL_STATE(50)] = 4001, + [SMALL_STATE(51)] = 4069, + [SMALL_STATE(52)] = 4137, + [SMALL_STATE(53)] = 4205, + [SMALL_STATE(54)] = 4266, + [SMALL_STATE(55)] = 4327, + [SMALL_STATE(56)] = 4388, + [SMALL_STATE(57)] = 4449, + [SMALL_STATE(58)] = 4510, + [SMALL_STATE(59)] = 4571, + [SMALL_STATE(60)] = 4632, + [SMALL_STATE(61)] = 4693, + [SMALL_STATE(62)] = 4754, + [SMALL_STATE(63)] = 4815, + [SMALL_STATE(64)] = 4876, + [SMALL_STATE(65)] = 4980, + [SMALL_STATE(66)] = 5063, + [SMALL_STATE(67)] = 5164, + [SMALL_STATE(68)] = 5265, + [SMALL_STATE(69)] = 5366, + [SMALL_STATE(70)] = 5451, + [SMALL_STATE(71)] = 5549, + [SMALL_STATE(72)] = 5647, + [SMALL_STATE(73)] = 5745, + [SMALL_STATE(74)] = 5840, + [SMALL_STATE(75)] = 5935, + [SMALL_STATE(76)] = 6004, + [SMALL_STATE(77)] = 6099, + [SMALL_STATE(78)] = 6194, + [SMALL_STATE(79)] = 6289, + [SMALL_STATE(80)] = 6384, + [SMALL_STATE(81)] = 6479, + [SMALL_STATE(82)] = 6574, + [SMALL_STATE(83)] = 6669, + [SMALL_STATE(84)] = 6764, + [SMALL_STATE(85)] = 6856, + [SMALL_STATE(86)] = 6948, + [SMALL_STATE(87)] = 7040, + [SMALL_STATE(88)] = 7132, + [SMALL_STATE(89)] = 7224, + [SMALL_STATE(90)] = 7316, + [SMALL_STATE(91)] = 7408, + [SMALL_STATE(92)] = 7500, + [SMALL_STATE(93)] = 7592, + [SMALL_STATE(94)] = 7684, + [SMALL_STATE(95)] = 7750, + [SMALL_STATE(96)] = 7842, + [SMALL_STATE(97)] = 7934, + [SMALL_STATE(98)] = 8026, + [SMALL_STATE(99)] = 8118, + [SMALL_STATE(100)] = 8210, + [SMALL_STATE(101)] = 8302, + [SMALL_STATE(102)] = 8394, + [SMALL_STATE(103)] = 8458, + [SMALL_STATE(104)] = 8550, + [SMALL_STATE(105)] = 8642, + [SMALL_STATE(106)] = 8734, + [SMALL_STATE(107)] = 8826, + [SMALL_STATE(108)] = 8918, + [SMALL_STATE(109)] = 9010, + [SMALL_STATE(110)] = 9102, + [SMALL_STATE(111)] = 9194, + [SMALL_STATE(112)] = 9283, + [SMALL_STATE(113)] = 9372, + [SMALL_STATE(114)] = 9461, + [SMALL_STATE(115)] = 9550, + [SMALL_STATE(116)] = 9639, + [SMALL_STATE(117)] = 9728, + [SMALL_STATE(118)] = 9817, + [SMALL_STATE(119)] = 9906, + [SMALL_STATE(120)] = 9995, + [SMALL_STATE(121)] = 10084, + [SMALL_STATE(122)] = 10173, + [SMALL_STATE(123)] = 10262, + [SMALL_STATE(124)] = 10351, + [SMALL_STATE(125)] = 10440, + [SMALL_STATE(126)] = 10529, + [SMALL_STATE(127)] = 10618, + [SMALL_STATE(128)] = 10707, + [SMALL_STATE(129)] = 10796, + [SMALL_STATE(130)] = 10885, + [SMALL_STATE(131)] = 10974, + [SMALL_STATE(132)] = 11063, + [SMALL_STATE(133)] = 11152, + [SMALL_STATE(134)] = 11241, + [SMALL_STATE(135)] = 11330, + [SMALL_STATE(136)] = 11419, + [SMALL_STATE(137)] = 11508, + [SMALL_STATE(138)] = 11597, + [SMALL_STATE(139)] = 11686, + [SMALL_STATE(140)] = 11775, + [SMALL_STATE(141)] = 11864, + [SMALL_STATE(142)] = 11953, + [SMALL_STATE(143)] = 12042, + [SMALL_STATE(144)] = 12131, + [SMALL_STATE(145)] = 12220, + [SMALL_STATE(146)] = 12309, + [SMALL_STATE(147)] = 12398, + [SMALL_STATE(148)] = 12487, + [SMALL_STATE(149)] = 12576, + [SMALL_STATE(150)] = 12665, + [SMALL_STATE(151)] = 12754, + [SMALL_STATE(152)] = 12843, + [SMALL_STATE(153)] = 12932, + [SMALL_STATE(154)] = 13021, + [SMALL_STATE(155)] = 13110, + [SMALL_STATE(156)] = 13199, + [SMALL_STATE(157)] = 13288, + [SMALL_STATE(158)] = 13377, + [SMALL_STATE(159)] = 13466, + [SMALL_STATE(160)] = 13555, + [SMALL_STATE(161)] = 13644, + [SMALL_STATE(162)] = 13733, + [SMALL_STATE(163)] = 13822, + [SMALL_STATE(164)] = 13911, + [SMALL_STATE(165)] = 14000, + [SMALL_STATE(166)] = 14089, + [SMALL_STATE(167)] = 14178, + [SMALL_STATE(168)] = 14267, + [SMALL_STATE(169)] = 14356, + [SMALL_STATE(170)] = 14445, + [SMALL_STATE(171)] = 14534, + [SMALL_STATE(172)] = 14623, + [SMALL_STATE(173)] = 14712, + [SMALL_STATE(174)] = 14798, + [SMALL_STATE(175)] = 14884, + [SMALL_STATE(176)] = 14970, + [SMALL_STATE(177)] = 15056, + [SMALL_STATE(178)] = 15142, + [SMALL_STATE(179)] = 15228, + [SMALL_STATE(180)] = 15314, + [SMALL_STATE(181)] = 15400, + [SMALL_STATE(182)] = 15486, + [SMALL_STATE(183)] = 15572, + [SMALL_STATE(184)] = 15658, + [SMALL_STATE(185)] = 15744, + [SMALL_STATE(186)] = 15830, + [SMALL_STATE(187)] = 15916, + [SMALL_STATE(188)] = 16002, + [SMALL_STATE(189)] = 16088, + [SMALL_STATE(190)] = 16152, + [SMALL_STATE(191)] = 16238, + [SMALL_STATE(192)] = 16324, + [SMALL_STATE(193)] = 16410, + [SMALL_STATE(194)] = 16496, + [SMALL_STATE(195)] = 16582, + [SMALL_STATE(196)] = 16668, + [SMALL_STATE(197)] = 16728, + [SMALL_STATE(198)] = 16788, + [SMALL_STATE(199)] = 16874, + [SMALL_STATE(200)] = 16960, + [SMALL_STATE(201)] = 17046, + [SMALL_STATE(202)] = 17132, + [SMALL_STATE(203)] = 17218, + [SMALL_STATE(204)] = 17304, + [SMALL_STATE(205)] = 17390, + [SMALL_STATE(206)] = 17476, + [SMALL_STATE(207)] = 17559, + [SMALL_STATE(208)] = 17642, + [SMALL_STATE(209)] = 17725, + [SMALL_STATE(210)] = 17808, + [SMALL_STATE(211)] = 17891, + [SMALL_STATE(212)] = 17974, + [SMALL_STATE(213)] = 18057, + [SMALL_STATE(214)] = 18118, + [SMALL_STATE(215)] = 18201, + [SMALL_STATE(216)] = 18284, + [SMALL_STATE(217)] = 18367, + [SMALL_STATE(218)] = 18450, + [SMALL_STATE(219)] = 18533, + [SMALL_STATE(220)] = 18616, + [SMALL_STATE(221)] = 18699, + [SMALL_STATE(222)] = 18782, + [SMALL_STATE(223)] = 18865, + [SMALL_STATE(224)] = 18948, + [SMALL_STATE(225)] = 19031, + [SMALL_STATE(226)] = 19114, + [SMALL_STATE(227)] = 19197, + [SMALL_STATE(228)] = 19280, + [SMALL_STATE(229)] = 19363, + [SMALL_STATE(230)] = 19446, + [SMALL_STATE(231)] = 19507, + [SMALL_STATE(232)] = 19590, + [SMALL_STATE(233)] = 19673, + [SMALL_STATE(234)] = 19756, + [SMALL_STATE(235)] = 19839, + [SMALL_STATE(236)] = 19922, + [SMALL_STATE(237)] = 20005, + [SMALL_STATE(238)] = 20062, + [SMALL_STATE(239)] = 20145, + [SMALL_STATE(240)] = 20228, + [SMALL_STATE(241)] = 20311, + [SMALL_STATE(242)] = 20394, + [SMALL_STATE(243)] = 20477, + [SMALL_STATE(244)] = 20560, + [SMALL_STATE(245)] = 20643, + [SMALL_STATE(246)] = 20726, + [SMALL_STATE(247)] = 20809, + [SMALL_STATE(248)] = 20892, + [SMALL_STATE(249)] = 20975, + [SMALL_STATE(250)] = 21058, + [SMALL_STATE(251)] = 21141, + [SMALL_STATE(252)] = 21224, + [SMALL_STATE(253)] = 21307, + [SMALL_STATE(254)] = 21390, + [SMALL_STATE(255)] = 21473, + [SMALL_STATE(256)] = 21556, + [SMALL_STATE(257)] = 21639, + [SMALL_STATE(258)] = 21722, + [SMALL_STATE(259)] = 21805, + [SMALL_STATE(260)] = 21888, + [SMALL_STATE(261)] = 21971, + [SMALL_STATE(262)] = 22054, + [SMALL_STATE(263)] = 22137, + [SMALL_STATE(264)] = 22220, + [SMALL_STATE(265)] = 22303, + [SMALL_STATE(266)] = 22386, + [SMALL_STATE(267)] = 22469, + [SMALL_STATE(268)] = 22552, + [SMALL_STATE(269)] = 22635, + [SMALL_STATE(270)] = 22718, + [SMALL_STATE(271)] = 22801, + [SMALL_STATE(272)] = 22884, + [SMALL_STATE(273)] = 22967, + [SMALL_STATE(274)] = 23050, + [SMALL_STATE(275)] = 23133, + [SMALL_STATE(276)] = 23216, + [SMALL_STATE(277)] = 23299, + [SMALL_STATE(278)] = 23382, + [SMALL_STATE(279)] = 23465, + [SMALL_STATE(280)] = 23548, + [SMALL_STATE(281)] = 23631, + [SMALL_STATE(282)] = 23714, + [SMALL_STATE(283)] = 23797, + [SMALL_STATE(284)] = 23880, + [SMALL_STATE(285)] = 23963, + [SMALL_STATE(286)] = 24046, + [SMALL_STATE(287)] = 24129, + [SMALL_STATE(288)] = 24212, + [SMALL_STATE(289)] = 24295, + [SMALL_STATE(290)] = 24378, + [SMALL_STATE(291)] = 24461, + [SMALL_STATE(292)] = 24544, + [SMALL_STATE(293)] = 24627, + [SMALL_STATE(294)] = 24710, + [SMALL_STATE(295)] = 24793, + [SMALL_STATE(296)] = 24876, + [SMALL_STATE(297)] = 24959, + [SMALL_STATE(298)] = 25042, + [SMALL_STATE(299)] = 25125, + [SMALL_STATE(300)] = 25208, + [SMALL_STATE(301)] = 25291, + [SMALL_STATE(302)] = 25374, + [SMALL_STATE(303)] = 25457, + [SMALL_STATE(304)] = 25540, + [SMALL_STATE(305)] = 25623, + [SMALL_STATE(306)] = 25706, + [SMALL_STATE(307)] = 25789, + [SMALL_STATE(308)] = 25872, + [SMALL_STATE(309)] = 25955, + [SMALL_STATE(310)] = 26038, + [SMALL_STATE(311)] = 26121, + [SMALL_STATE(312)] = 26204, + [SMALL_STATE(313)] = 26287, + [SMALL_STATE(314)] = 26370, + [SMALL_STATE(315)] = 26453, + [SMALL_STATE(316)] = 26536, + [SMALL_STATE(317)] = 26619, + [SMALL_STATE(318)] = 26702, + [SMALL_STATE(319)] = 26785, + [SMALL_STATE(320)] = 26868, + [SMALL_STATE(321)] = 26929, + [SMALL_STATE(322)] = 27012, + [SMALL_STATE(323)] = 27095, + [SMALL_STATE(324)] = 27178, + [SMALL_STATE(325)] = 27261, + [SMALL_STATE(326)] = 27344, + [SMALL_STATE(327)] = 27427, + [SMALL_STATE(328)] = 27510, + [SMALL_STATE(329)] = 27593, + [SMALL_STATE(330)] = 27676, + [SMALL_STATE(331)] = 27759, + [SMALL_STATE(332)] = 27842, + [SMALL_STATE(333)] = 27925, + [SMALL_STATE(334)] = 28008, + [SMALL_STATE(335)] = 28066, + [SMALL_STATE(336)] = 28124, + [SMALL_STATE(337)] = 28182, + [SMALL_STATE(338)] = 28240, + [SMALL_STATE(339)] = 28317, + [SMALL_STATE(340)] = 28394, + [SMALL_STATE(341)] = 28471, + [SMALL_STATE(342)] = 28548, + [SMALL_STATE(343)] = 28625, + [SMALL_STATE(344)] = 28680, + [SMALL_STATE(345)] = 28735, + [SMALL_STATE(346)] = 28790, + [SMALL_STATE(347)] = 28867, + [SMALL_STATE(348)] = 28944, + [SMALL_STATE(349)] = 29021, + [SMALL_STATE(350)] = 29098, + [SMALL_STATE(351)] = 29175, + [SMALL_STATE(352)] = 29230, + [SMALL_STATE(353)] = 29307, + [SMALL_STATE(354)] = 29384, + [SMALL_STATE(355)] = 29461, + [SMALL_STATE(356)] = 29538, + [SMALL_STATE(357)] = 29615, + [SMALL_STATE(358)] = 29692, + [SMALL_STATE(359)] = 29769, + [SMALL_STATE(360)] = 29846, + [SMALL_STATE(361)] = 29923, + [SMALL_STATE(362)] = 29978, + [SMALL_STATE(363)] = 30033, + [SMALL_STATE(364)] = 30110, + [SMALL_STATE(365)] = 30187, + [SMALL_STATE(366)] = 30264, + [SMALL_STATE(367)] = 30341, + [SMALL_STATE(368)] = 30418, + [SMALL_STATE(369)] = 30495, + [SMALL_STATE(370)] = 30572, + [SMALL_STATE(371)] = 30649, + [SMALL_STATE(372)] = 30726, + [SMALL_STATE(373)] = 30803, + [SMALL_STATE(374)] = 30880, + [SMALL_STATE(375)] = 30957, + [SMALL_STATE(376)] = 31034, + [SMALL_STATE(377)] = 31111, + [SMALL_STATE(378)] = 31164, + [SMALL_STATE(379)] = 31241, + [SMALL_STATE(380)] = 31318, + [SMALL_STATE(381)] = 31395, + [SMALL_STATE(382)] = 31472, + [SMALL_STATE(383)] = 31549, + [SMALL_STATE(384)] = 31626, + [SMALL_STATE(385)] = 31703, + [SMALL_STATE(386)] = 31780, + [SMALL_STATE(387)] = 31857, + [SMALL_STATE(388)] = 31934, + [SMALL_STATE(389)] = 32011, + [SMALL_STATE(390)] = 32088, + [SMALL_STATE(391)] = 32165, + [SMALL_STATE(392)] = 32220, + [SMALL_STATE(393)] = 32297, + [SMALL_STATE(394)] = 32374, + [SMALL_STATE(395)] = 32429, + [SMALL_STATE(396)] = 32506, + [SMALL_STATE(397)] = 32583, + [SMALL_STATE(398)] = 32660, + [SMALL_STATE(399)] = 32715, + [SMALL_STATE(400)] = 32792, + [SMALL_STATE(401)] = 32869, + [SMALL_STATE(402)] = 32946, + [SMALL_STATE(403)] = 33023, + [SMALL_STATE(404)] = 33078, + [SMALL_STATE(405)] = 33133, + [SMALL_STATE(406)] = 33210, + [SMALL_STATE(407)] = 33287, + [SMALL_STATE(408)] = 33364, + [SMALL_STATE(409)] = 33441, + [SMALL_STATE(410)] = 33518, + [SMALL_STATE(411)] = 33595, + [SMALL_STATE(412)] = 33672, + [SMALL_STATE(413)] = 33749, + [SMALL_STATE(414)] = 33826, + [SMALL_STATE(415)] = 33903, + [SMALL_STATE(416)] = 33980, + [SMALL_STATE(417)] = 34057, + [SMALL_STATE(418)] = 34134, + [SMALL_STATE(419)] = 34211, + [SMALL_STATE(420)] = 34272, + [SMALL_STATE(421)] = 34349, + [SMALL_STATE(422)] = 34426, + [SMALL_STATE(423)] = 34503, + [SMALL_STATE(424)] = 34580, + [SMALL_STATE(425)] = 34657, + [SMALL_STATE(426)] = 34734, + [SMALL_STATE(427)] = 34811, + [SMALL_STATE(428)] = 34888, + [SMALL_STATE(429)] = 34965, + [SMALL_STATE(430)] = 35042, + [SMALL_STATE(431)] = 35119, + [SMALL_STATE(432)] = 35196, + [SMALL_STATE(433)] = 35273, + [SMALL_STATE(434)] = 35350, + [SMALL_STATE(435)] = 35427, + [SMALL_STATE(436)] = 35504, + [SMALL_STATE(437)] = 35581, + [SMALL_STATE(438)] = 35658, + [SMALL_STATE(439)] = 35735, + [SMALL_STATE(440)] = 35812, + [SMALL_STATE(441)] = 35889, + [SMALL_STATE(442)] = 35966, + [SMALL_STATE(443)] = 36043, + [SMALL_STATE(444)] = 36120, + [SMALL_STATE(445)] = 36197, + [SMALL_STATE(446)] = 36274, + [SMALL_STATE(447)] = 36351, + [SMALL_STATE(448)] = 36428, + [SMALL_STATE(449)] = 36505, + [SMALL_STATE(450)] = 36582, + [SMALL_STATE(451)] = 36659, + [SMALL_STATE(452)] = 36736, + [SMALL_STATE(453)] = 36813, + [SMALL_STATE(454)] = 36890, + [SMALL_STATE(455)] = 36967, + [SMALL_STATE(456)] = 37044, + [SMALL_STATE(457)] = 37121, + [SMALL_STATE(458)] = 37198, + [SMALL_STATE(459)] = 37275, + [SMALL_STATE(460)] = 37352, + [SMALL_STATE(461)] = 37429, + [SMALL_STATE(462)] = 37506, + [SMALL_STATE(463)] = 37583, + [SMALL_STATE(464)] = 37660, + [SMALL_STATE(465)] = 37737, + [SMALL_STATE(466)] = 37809, + [SMALL_STATE(467)] = 37861, + [SMALL_STATE(468)] = 37913, + [SMALL_STATE(469)] = 37965, + [SMALL_STATE(470)] = 38039, + [SMALL_STATE(471)] = 38109, + [SMALL_STATE(472)] = 38161, + [SMALL_STATE(473)] = 38219, + [SMALL_STATE(474)] = 38277, + [SMALL_STATE(475)] = 38335, + [SMALL_STATE(476)] = 38406, + [SMALL_STATE(477)] = 38475, + [SMALL_STATE(478)] = 38546, + [SMALL_STATE(479)] = 38587, + [SMALL_STATE(480)] = 38658, + [SMALL_STATE(481)] = 38729, + [SMALL_STATE(482)] = 38778, + [SMALL_STATE(483)] = 38849, + [SMALL_STATE(484)] = 38920, + [SMALL_STATE(485)] = 38991, + [SMALL_STATE(486)] = 39062, + [SMALL_STATE(487)] = 39133, + [SMALL_STATE(488)] = 39204, + [SMALL_STATE(489)] = 39275, + [SMALL_STATE(490)] = 39346, + [SMALL_STATE(491)] = 39417, + [SMALL_STATE(492)] = 39488, + [SMALL_STATE(493)] = 39559, + [SMALL_STATE(494)] = 39630, + [SMALL_STATE(495)] = 39701, + [SMALL_STATE(496)] = 39772, + [SMALL_STATE(497)] = 39843, + [SMALL_STATE(498)] = 39914, + [SMALL_STATE(499)] = 39985, + [SMALL_STATE(500)] = 40056, + [SMALL_STATE(501)] = 40127, + [SMALL_STATE(502)] = 40198, + [SMALL_STATE(503)] = 40269, + [SMALL_STATE(504)] = 40340, + [SMALL_STATE(505)] = 40411, + [SMALL_STATE(506)] = 40482, + [SMALL_STATE(507)] = 40553, + [SMALL_STATE(508)] = 40608, + [SMALL_STATE(509)] = 40679, + [SMALL_STATE(510)] = 40750, + [SMALL_STATE(511)] = 40821, + [SMALL_STATE(512)] = 40892, + [SMALL_STATE(513)] = 40963, + [SMALL_STATE(514)] = 41034, + [SMALL_STATE(515)] = 41105, + [SMALL_STATE(516)] = 41176, + [SMALL_STATE(517)] = 41247, + [SMALL_STATE(518)] = 41318, + [SMALL_STATE(519)] = 41359, + [SMALL_STATE(520)] = 41430, + [SMALL_STATE(521)] = 41501, + [SMALL_STATE(522)] = 41572, + [SMALL_STATE(523)] = 41643, + [SMALL_STATE(524)] = 41684, + [SMALL_STATE(525)] = 41755, + [SMALL_STATE(526)] = 41826, + [SMALL_STATE(527)] = 41897, + [SMALL_STATE(528)] = 41968, + [SMALL_STATE(529)] = 42039, + [SMALL_STATE(530)] = 42110, + [SMALL_STATE(531)] = 42181, + [SMALL_STATE(532)] = 42252, + [SMALL_STATE(533)] = 42323, + [SMALL_STATE(534)] = 42394, + [SMALL_STATE(535)] = 42465, + [SMALL_STATE(536)] = 42514, + [SMALL_STATE(537)] = 42585, + [SMALL_STATE(538)] = 42656, + [SMALL_STATE(539)] = 42727, + [SMALL_STATE(540)] = 42798, + [SMALL_STATE(541)] = 42869, + [SMALL_STATE(542)] = 42940, + [SMALL_STATE(543)] = 43011, + [SMALL_STATE(544)] = 43082, + [SMALL_STATE(545)] = 43153, + [SMALL_STATE(546)] = 43222, + [SMALL_STATE(547)] = 43293, + [SMALL_STATE(548)] = 43364, + [SMALL_STATE(549)] = 43405, + [SMALL_STATE(550)] = 43476, + [SMALL_STATE(551)] = 43547, + [SMALL_STATE(552)] = 43618, + [SMALL_STATE(553)] = 43667, + [SMALL_STATE(554)] = 43738, + [SMALL_STATE(555)] = 43809, + [SMALL_STATE(556)] = 43880, + [SMALL_STATE(557)] = 43951, + [SMALL_STATE(558)] = 44022, + [SMALL_STATE(559)] = 44093, + [SMALL_STATE(560)] = 44164, + [SMALL_STATE(561)] = 44235, + [SMALL_STATE(562)] = 44306, + [SMALL_STATE(563)] = 44377, + [SMALL_STATE(564)] = 44448, + [SMALL_STATE(565)] = 44519, + [SMALL_STATE(566)] = 44590, + [SMALL_STATE(567)] = 44633, + [SMALL_STATE(568)] = 44704, + [SMALL_STATE(569)] = 44775, + [SMALL_STATE(570)] = 44846, + [SMALL_STATE(571)] = 44917, + [SMALL_STATE(572)] = 44988, + [SMALL_STATE(573)] = 45059, + [SMALL_STATE(574)] = 45130, + [SMALL_STATE(575)] = 45201, + [SMALL_STATE(576)] = 45272, + [SMALL_STATE(577)] = 45343, + [SMALL_STATE(578)] = 45414, + [SMALL_STATE(579)] = 45485, + [SMALL_STATE(580)] = 45556, + [SMALL_STATE(581)] = 45627, + [SMALL_STATE(582)] = 45698, + [SMALL_STATE(583)] = 45769, + [SMALL_STATE(584)] = 45840, + [SMALL_STATE(585)] = 45911, + [SMALL_STATE(586)] = 45952, + [SMALL_STATE(587)] = 46023, + [SMALL_STATE(588)] = 46094, + [SMALL_STATE(589)] = 46165, + [SMALL_STATE(590)] = 46236, + [SMALL_STATE(591)] = 46307, + [SMALL_STATE(592)] = 46378, + [SMALL_STATE(593)] = 46449, + [SMALL_STATE(594)] = 46520, + [SMALL_STATE(595)] = 46591, + [SMALL_STATE(596)] = 46662, + [SMALL_STATE(597)] = 46733, + [SMALL_STATE(598)] = 46788, + [SMALL_STATE(599)] = 46829, + [SMALL_STATE(600)] = 46900, + [SMALL_STATE(601)] = 46971, + [SMALL_STATE(602)] = 47042, + [SMALL_STATE(603)] = 47113, + [SMALL_STATE(604)] = 47184, + [SMALL_STATE(605)] = 47255, + [SMALL_STATE(606)] = 47296, + [SMALL_STATE(607)] = 47367, + [SMALL_STATE(608)] = 47438, + [SMALL_STATE(609)] = 47509, + [SMALL_STATE(610)] = 47580, + [SMALL_STATE(611)] = 47651, + [SMALL_STATE(612)] = 47722, + [SMALL_STATE(613)] = 47793, + [SMALL_STATE(614)] = 47864, + [SMALL_STATE(615)] = 47935, + [SMALL_STATE(616)] = 48006, + [SMALL_STATE(617)] = 48077, + [SMALL_STATE(618)] = 48148, + [SMALL_STATE(619)] = 48219, + [SMALL_STATE(620)] = 48290, + [SMALL_STATE(621)] = 48361, + [SMALL_STATE(622)] = 48432, + [SMALL_STATE(623)] = 48503, + [SMALL_STATE(624)] = 48574, + [SMALL_STATE(625)] = 48645, + [SMALL_STATE(626)] = 48716, + [SMALL_STATE(627)] = 48787, + [SMALL_STATE(628)] = 48858, + [SMALL_STATE(629)] = 48929, + [SMALL_STATE(630)] = 48978, + [SMALL_STATE(631)] = 49049, + [SMALL_STATE(632)] = 49120, + [SMALL_STATE(633)] = 49191, + [SMALL_STATE(634)] = 49262, + [SMALL_STATE(635)] = 49333, + [SMALL_STATE(636)] = 49404, + [SMALL_STATE(637)] = 49475, + [SMALL_STATE(638)] = 49546, + [SMALL_STATE(639)] = 49617, + [SMALL_STATE(640)] = 49688, + [SMALL_STATE(641)] = 49729, + [SMALL_STATE(642)] = 49800, + [SMALL_STATE(643)] = 49849, + [SMALL_STATE(644)] = 49920, + [SMALL_STATE(645)] = 49991, + [SMALL_STATE(646)] = 50062, + [SMALL_STATE(647)] = 50133, + [SMALL_STATE(648)] = 50204, + [SMALL_STATE(649)] = 50259, + [SMALL_STATE(650)] = 50330, + [SMALL_STATE(651)] = 50401, + [SMALL_STATE(652)] = 50472, + [SMALL_STATE(653)] = 50513, + [SMALL_STATE(654)] = 50584, + [SMALL_STATE(655)] = 50655, + [SMALL_STATE(656)] = 50726, + [SMALL_STATE(657)] = 50767, + [SMALL_STATE(658)] = 50838, + [SMALL_STATE(659)] = 50909, + [SMALL_STATE(660)] = 50980, + [SMALL_STATE(661)] = 51051, + [SMALL_STATE(662)] = 51122, + [SMALL_STATE(663)] = 51193, + [SMALL_STATE(664)] = 51232, + [SMALL_STATE(665)] = 51281, + [SMALL_STATE(666)] = 51330, + [SMALL_STATE(667)] = 51379, + [SMALL_STATE(668)] = 51418, + [SMALL_STATE(669)] = 51457, + [SMALL_STATE(670)] = 51496, + [SMALL_STATE(671)] = 51534, + [SMALL_STATE(672)] = 51572, + [SMALL_STATE(673)] = 51610, + [SMALL_STATE(674)] = 51648, + [SMALL_STATE(675)] = 51686, + [SMALL_STATE(676)] = 51724, + [SMALL_STATE(677)] = 51762, + [SMALL_STATE(678)] = 51800, + [SMALL_STATE(679)] = 51838, + [SMALL_STATE(680)] = 51876, + [SMALL_STATE(681)] = 51914, + [SMALL_STATE(682)] = 51952, + [SMALL_STATE(683)] = 51990, + [SMALL_STATE(684)] = 52028, + [SMALL_STATE(685)] = 52066, + [SMALL_STATE(686)] = 52104, + [SMALL_STATE(687)] = 52142, + [SMALL_STATE(688)] = 52180, + [SMALL_STATE(689)] = 52218, + [SMALL_STATE(690)] = 52256, + [SMALL_STATE(691)] = 52294, + [SMALL_STATE(692)] = 52332, + [SMALL_STATE(693)] = 52370, + [SMALL_STATE(694)] = 52408, + [SMALL_STATE(695)] = 52446, + [SMALL_STATE(696)] = 52484, + [SMALL_STATE(697)] = 52522, + [SMALL_STATE(698)] = 52560, + [SMALL_STATE(699)] = 52598, + [SMALL_STATE(700)] = 52636, + [SMALL_STATE(701)] = 52674, + [SMALL_STATE(702)] = 52712, + [SMALL_STATE(703)] = 52750, + [SMALL_STATE(704)] = 52788, + [SMALL_STATE(705)] = 52826, + [SMALL_STATE(706)] = 52864, + [SMALL_STATE(707)] = 52902, + [SMALL_STATE(708)] = 52940, + [SMALL_STATE(709)] = 52978, + [SMALL_STATE(710)] = 53016, + [SMALL_STATE(711)] = 53054, + [SMALL_STATE(712)] = 53092, + [SMALL_STATE(713)] = 53135, + [SMALL_STATE(714)] = 53178, + [SMALL_STATE(715)] = 53221, + [SMALL_STATE(716)] = 53264, + [SMALL_STATE(717)] = 53307, + [SMALL_STATE(718)] = 53350, + [SMALL_STATE(719)] = 53390, + [SMALL_STATE(720)] = 53430, + [SMALL_STATE(721)] = 53470, + [SMALL_STATE(722)] = 53510, + [SMALL_STATE(723)] = 53550, + [SMALL_STATE(724)] = 53590, + [SMALL_STATE(725)] = 53629, + [SMALL_STATE(726)] = 53668, + [SMALL_STATE(727)] = 53707, + [SMALL_STATE(728)] = 53750, + [SMALL_STATE(729)] = 53786, + [SMALL_STATE(730)] = 53826, + [SMALL_STATE(731)] = 53866, + [SMALL_STATE(732)] = 53902, + [SMALL_STATE(733)] = 53942, + [SMALL_STATE(734)] = 53982, + [SMALL_STATE(735)] = 54039, + [SMALL_STATE(736)] = 54096, + [SMALL_STATE(737)] = 54139, + [SMALL_STATE(738)] = 54196, + [SMALL_STATE(739)] = 54253, + [SMALL_STATE(740)] = 54308, + [SMALL_STATE(741)] = 54362, + [SMALL_STATE(742)] = 54402, + [SMALL_STATE(743)] = 54456, + [SMALL_STATE(744)] = 54496, + [SMALL_STATE(745)] = 54540, + [SMALL_STATE(746)] = 54594, + [SMALL_STATE(747)] = 54634, + [SMALL_STATE(748)] = 54688, + [SMALL_STATE(749)] = 54730, + [SMALL_STATE(750)] = 54784, + [SMALL_STATE(751)] = 54838, + [SMALL_STATE(752)] = 54892, + [SMALL_STATE(753)] = 54946, + [SMALL_STATE(754)] = 55000, + [SMALL_STATE(755)] = 55054, + [SMALL_STATE(756)] = 55104, + [SMALL_STATE(757)] = 55158, + [SMALL_STATE(758)] = 55212, + [SMALL_STATE(759)] = 55266, + [SMALL_STATE(760)] = 55316, + [SMALL_STATE(761)] = 55369, + [SMALL_STATE(762)] = 55408, + [SMALL_STATE(763)] = 55455, + [SMALL_STATE(764)] = 55494, + [SMALL_STATE(765)] = 55533, + [SMALL_STATE(766)] = 55584, + [SMALL_STATE(767)] = 55625, + [SMALL_STATE(768)] = 55666, + [SMALL_STATE(769)] = 55717, + [SMALL_STATE(770)] = 55758, + [SMALL_STATE(771)] = 55805, + [SMALL_STATE(772)] = 55853, + [SMALL_STATE(773)] = 55901, + [SMALL_STATE(774)] = 55945, + [SMALL_STATE(775)] = 55993, + [SMALL_STATE(776)] = 56041, + [SMALL_STATE(777)] = 56089, + [SMALL_STATE(778)] = 56137, + [SMALL_STATE(779)] = 56181, + [SMALL_STATE(780)] = 56229, + [SMALL_STATE(781)] = 56277, + [SMALL_STATE(782)] = 56311, + [SMALL_STATE(783)] = 56361, + [SMALL_STATE(784)] = 56409, + [SMALL_STATE(785)] = 56457, + [SMALL_STATE(786)] = 56505, + [SMALL_STATE(787)] = 56539, + [SMALL_STATE(788)] = 56571, + [SMALL_STATE(789)] = 56603, + [SMALL_STATE(790)] = 56637, + [SMALL_STATE(791)] = 56685, + [SMALL_STATE(792)] = 56733, + [SMALL_STATE(793)] = 56781, + [SMALL_STATE(794)] = 56810, + [SMALL_STATE(795)] = 56843, + [SMALL_STATE(796)] = 56874, + [SMALL_STATE(797)] = 56905, + [SMALL_STATE(798)] = 56938, + [SMALL_STATE(799)] = 56971, + [SMALL_STATE(800)] = 57004, + [SMALL_STATE(801)] = 57049, + [SMALL_STATE(802)] = 57078, + [SMALL_STATE(803)] = 57107, + [SMALL_STATE(804)] = 57136, + [SMALL_STATE(805)] = 57165, + [SMALL_STATE(806)] = 57210, + [SMALL_STATE(807)] = 57239, + [SMALL_STATE(808)] = 57268, + [SMALL_STATE(809)] = 57297, + [SMALL_STATE(810)] = 57326, + [SMALL_STATE(811)] = 57369, + [SMALL_STATE(812)] = 57410, + [SMALL_STATE(813)] = 57441, + [SMALL_STATE(814)] = 57470, + [SMALL_STATE(815)] = 57499, + [SMALL_STATE(816)] = 57528, + [SMALL_STATE(817)] = 57557, + [SMALL_STATE(818)] = 57600, + [SMALL_STATE(819)] = 57629, + [SMALL_STATE(820)] = 57658, + [SMALL_STATE(821)] = 57687, + [SMALL_STATE(822)] = 57716, + [SMALL_STATE(823)] = 57745, + [SMALL_STATE(824)] = 57774, + [SMALL_STATE(825)] = 57803, + [SMALL_STATE(826)] = 57832, + [SMALL_STATE(827)] = 57861, + [SMALL_STATE(828)] = 57890, + [SMALL_STATE(829)] = 57919, + [SMALL_STATE(830)] = 57948, + [SMALL_STATE(831)] = 57977, + [SMALL_STATE(832)] = 58012, + [SMALL_STATE(833)] = 58057, + [SMALL_STATE(834)] = 58090, + [SMALL_STATE(835)] = 58123, + [SMALL_STATE(836)] = 58156, + [SMALL_STATE(837)] = 58189, + [SMALL_STATE(838)] = 58224, + [SMALL_STATE(839)] = 58269, + [SMALL_STATE(840)] = 58308, + [SMALL_STATE(841)] = 58353, + [SMALL_STATE(842)] = 58394, + [SMALL_STATE(843)] = 58429, + [SMALL_STATE(844)] = 58455, + [SMALL_STATE(845)] = 58485, + [SMALL_STATE(846)] = 58513, + [SMALL_STATE(847)] = 58541, + [SMALL_STATE(848)] = 58569, + [SMALL_STATE(849)] = 58597, + [SMALL_STATE(850)] = 58625, + [SMALL_STATE(851)] = 58653, + [SMALL_STATE(852)] = 58681, + [SMALL_STATE(853)] = 58709, + [SMALL_STATE(854)] = 58737, + [SMALL_STATE(855)] = 58765, + [SMALL_STATE(856)] = 58793, + [SMALL_STATE(857)] = 58821, + [SMALL_STATE(858)] = 58849, + [SMALL_STATE(859)] = 58877, + [SMALL_STATE(860)] = 58905, + [SMALL_STATE(861)] = 58933, + [SMALL_STATE(862)] = 58961, + [SMALL_STATE(863)] = 58989, + [SMALL_STATE(864)] = 59019, + [SMALL_STATE(865)] = 59045, + [SMALL_STATE(866)] = 59071, + [SMALL_STATE(867)] = 59097, + [SMALL_STATE(868)] = 59123, + [SMALL_STATE(869)] = 59149, + [SMALL_STATE(870)] = 59175, + [SMALL_STATE(871)] = 59201, + [SMALL_STATE(872)] = 59227, + [SMALL_STATE(873)] = 59253, + [SMALL_STATE(874)] = 59279, + [SMALL_STATE(875)] = 59309, + [SMALL_STATE(876)] = 59351, + [SMALL_STATE(877)] = 59381, + [SMALL_STATE(878)] = 59407, + [SMALL_STATE(879)] = 59433, + [SMALL_STATE(880)] = 59459, + [SMALL_STATE(881)] = 59485, + [SMALL_STATE(882)] = 59511, + [SMALL_STATE(883)] = 59539, + [SMALL_STATE(884)] = 59565, + [SMALL_STATE(885)] = 59593, + [SMALL_STATE(886)] = 59621, + [SMALL_STATE(887)] = 59649, + [SMALL_STATE(888)] = 59675, + [SMALL_STATE(889)] = 59701, + [SMALL_STATE(890)] = 59727, + [SMALL_STATE(891)] = 59753, + [SMALL_STATE(892)] = 59779, + [SMALL_STATE(893)] = 59805, + [SMALL_STATE(894)] = 59835, + [SMALL_STATE(895)] = 59861, + [SMALL_STATE(896)] = 59887, + [SMALL_STATE(897)] = 59913, + [SMALL_STATE(898)] = 59939, + [SMALL_STATE(899)] = 59965, + [SMALL_STATE(900)] = 59991, + [SMALL_STATE(901)] = 60017, + [SMALL_STATE(902)] = 60043, + [SMALL_STATE(903)] = 60069, + [SMALL_STATE(904)] = 60095, + [SMALL_STATE(905)] = 60121, + [SMALL_STATE(906)] = 60147, + [SMALL_STATE(907)] = 60173, + [SMALL_STATE(908)] = 60199, + [SMALL_STATE(909)] = 60225, + [SMALL_STATE(910)] = 60251, + [SMALL_STATE(911)] = 60277, + [SMALL_STATE(912)] = 60303, + [SMALL_STATE(913)] = 60329, + [SMALL_STATE(914)] = 60355, + [SMALL_STATE(915)] = 60385, + [SMALL_STATE(916)] = 60411, + [SMALL_STATE(917)] = 60437, + [SMALL_STATE(918)] = 60463, + [SMALL_STATE(919)] = 60489, + [SMALL_STATE(920)] = 60515, + [SMALL_STATE(921)] = 60541, + [SMALL_STATE(922)] = 60567, + [SMALL_STATE(923)] = 60593, + [SMALL_STATE(924)] = 60619, + [SMALL_STATE(925)] = 60645, + [SMALL_STATE(926)] = 60671, + [SMALL_STATE(927)] = 60697, + [SMALL_STATE(928)] = 60723, + [SMALL_STATE(929)] = 60749, + [SMALL_STATE(930)] = 60775, + [SMALL_STATE(931)] = 60801, + [SMALL_STATE(932)] = 60831, + [SMALL_STATE(933)] = 60857, + [SMALL_STATE(934)] = 60883, + [SMALL_STATE(935)] = 60909, + [SMALL_STATE(936)] = 60935, + [SMALL_STATE(937)] = 60961, + [SMALL_STATE(938)] = 60987, + [SMALL_STATE(939)] = 61013, + [SMALL_STATE(940)] = 61039, + [SMALL_STATE(941)] = 61065, + [SMALL_STATE(942)] = 61091, + [SMALL_STATE(943)] = 61117, + [SMALL_STATE(944)] = 61143, + [SMALL_STATE(945)] = 61169, + [SMALL_STATE(946)] = 61195, + [SMALL_STATE(947)] = 61221, + [SMALL_STATE(948)] = 61247, + [SMALL_STATE(949)] = 61277, + [SMALL_STATE(950)] = 61319, + [SMALL_STATE(951)] = 61349, + [SMALL_STATE(952)] = 61385, + [SMALL_STATE(953)] = 61421, + [SMALL_STATE(954)] = 61463, + [SMALL_STATE(955)] = 61505, + [SMALL_STATE(956)] = 61533, + [SMALL_STATE(957)] = 61575, + [SMALL_STATE(958)] = 61617, + [SMALL_STATE(959)] = 61657, + [SMALL_STATE(960)] = 61699, + [SMALL_STATE(961)] = 61741, + [SMALL_STATE(962)] = 61783, + [SMALL_STATE(963)] = 61825, + [SMALL_STATE(964)] = 61853, + [SMALL_STATE(965)] = 61883, + [SMALL_STATE(966)] = 61913, + [SMALL_STATE(967)] = 61955, + [SMALL_STATE(968)] = 61983, + [SMALL_STATE(969)] = 62013, + [SMALL_STATE(970)] = 62043, + [SMALL_STATE(971)] = 62085, + [SMALL_STATE(972)] = 62113, + [SMALL_STATE(973)] = 62153, + [SMALL_STATE(974)] = 62195, + [SMALL_STATE(975)] = 62231, + [SMALL_STATE(976)] = 62271, + [SMALL_STATE(977)] = 62313, + [SMALL_STATE(978)] = 62355, + [SMALL_STATE(979)] = 62397, + [SMALL_STATE(980)] = 62427, + [SMALL_STATE(981)] = 62457, + [SMALL_STATE(982)] = 62499, + [SMALL_STATE(983)] = 62541, + [SMALL_STATE(984)] = 62571, + [SMALL_STATE(985)] = 62601, + [SMALL_STATE(986)] = 62641, + [SMALL_STATE(987)] = 62683, + [SMALL_STATE(988)] = 62725, + [SMALL_STATE(989)] = 62767, + [SMALL_STATE(990)] = 62809, + [SMALL_STATE(991)] = 62851, + [SMALL_STATE(992)] = 62881, + [SMALL_STATE(993)] = 62911, + [SMALL_STATE(994)] = 62941, + [SMALL_STATE(995)] = 62971, + [SMALL_STATE(996)] = 63013, + [SMALL_STATE(997)] = 63055, + [SMALL_STATE(998)] = 63097, + [SMALL_STATE(999)] = 63139, + [SMALL_STATE(1000)] = 63181, + [SMALL_STATE(1001)] = 63223, + [SMALL_STATE(1002)] = 63265, + [SMALL_STATE(1003)] = 63307, + [SMALL_STATE(1004)] = 63337, + [SMALL_STATE(1005)] = 63367, + [SMALL_STATE(1006)] = 63397, + [SMALL_STATE(1007)] = 63427, + [SMALL_STATE(1008)] = 63457, + [SMALL_STATE(1009)] = 63483, + [SMALL_STATE(1010)] = 63510, + [SMALL_STATE(1011)] = 63535, + [SMALL_STATE(1012)] = 63560, + [SMALL_STATE(1013)] = 63587, + [SMALL_STATE(1014)] = 63614, + [SMALL_STATE(1015)] = 63641, + [SMALL_STATE(1016)] = 63668, + [SMALL_STATE(1017)] = 63695, + [SMALL_STATE(1018)] = 63722, + [SMALL_STATE(1019)] = 63749, + [SMALL_STATE(1020)] = 63774, + [SMALL_STATE(1021)] = 63799, + [SMALL_STATE(1022)] = 63826, + [SMALL_STATE(1023)] = 63851, + [SMALL_STATE(1024)] = 63876, + [SMALL_STATE(1025)] = 63901, + [SMALL_STATE(1026)] = 63926, + [SMALL_STATE(1027)] = 63951, + [SMALL_STATE(1028)] = 63978, + [SMALL_STATE(1029)] = 64003, + [SMALL_STATE(1030)] = 64028, + [SMALL_STATE(1031)] = 64053, + [SMALL_STATE(1032)] = 64078, + [SMALL_STATE(1033)] = 64103, + [SMALL_STATE(1034)] = 64130, + [SMALL_STATE(1035)] = 64155, + [SMALL_STATE(1036)] = 64182, + [SMALL_STATE(1037)] = 64209, + [SMALL_STATE(1038)] = 64234, + [SMALL_STATE(1039)] = 64259, + [SMALL_STATE(1040)] = 64286, + [SMALL_STATE(1041)] = 64313, + [SMALL_STATE(1042)] = 64340, + [SMALL_STATE(1043)] = 64367, + [SMALL_STATE(1044)] = 64392, + [SMALL_STATE(1045)] = 64417, + [SMALL_STATE(1046)] = 64442, + [SMALL_STATE(1047)] = 64467, + [SMALL_STATE(1048)] = 64492, + [SMALL_STATE(1049)] = 64517, + [SMALL_STATE(1050)] = 64542, + [SMALL_STATE(1051)] = 64569, + [SMALL_STATE(1052)] = 64596, + [SMALL_STATE(1053)] = 64621, + [SMALL_STATE(1054)] = 64646, + [SMALL_STATE(1055)] = 64671, + [SMALL_STATE(1056)] = 64696, + [SMALL_STATE(1057)] = 64735, + [SMALL_STATE(1058)] = 64762, + [SMALL_STATE(1059)] = 64787, + [SMALL_STATE(1060)] = 64812, + [SMALL_STATE(1061)] = 64839, + [SMALL_STATE(1062)] = 64864, + [SMALL_STATE(1063)] = 64889, + [SMALL_STATE(1064)] = 64914, + [SMALL_STATE(1065)] = 64941, + [SMALL_STATE(1066)] = 64966, + [SMALL_STATE(1067)] = 64991, + [SMALL_STATE(1068)] = 65018, + [SMALL_STATE(1069)] = 65045, + [SMALL_STATE(1070)] = 65072, + [SMALL_STATE(1071)] = 65099, + [SMALL_STATE(1072)] = 65126, + [SMALL_STATE(1073)] = 65153, + [SMALL_STATE(1074)] = 65180, + [SMALL_STATE(1075)] = 65207, + [SMALL_STATE(1076)] = 65234, + [SMALL_STATE(1077)] = 65261, + [SMALL_STATE(1078)] = 65288, + [SMALL_STATE(1079)] = 65315, + [SMALL_STATE(1080)] = 65340, + [SMALL_STATE(1081)] = 65367, + [SMALL_STATE(1082)] = 65394, + [SMALL_STATE(1083)] = 65419, + [SMALL_STATE(1084)] = 65446, + [SMALL_STATE(1085)] = 65473, + [SMALL_STATE(1086)] = 65500, + [SMALL_STATE(1087)] = 65527, + [SMALL_STATE(1088)] = 65552, + [SMALL_STATE(1089)] = 65579, + [SMALL_STATE(1090)] = 65606, + [SMALL_STATE(1091)] = 65631, + [SMALL_STATE(1092)] = 65670, + [SMALL_STATE(1093)] = 65695, + [SMALL_STATE(1094)] = 65734, + [SMALL_STATE(1095)] = 65761, + [SMALL_STATE(1096)] = 65788, + [SMALL_STATE(1097)] = 65827, + [SMALL_STATE(1098)] = 65854, + [SMALL_STATE(1099)] = 65879, + [SMALL_STATE(1100)] = 65904, + [SMALL_STATE(1101)] = 65929, + [SMALL_STATE(1102)] = 65956, + [SMALL_STATE(1103)] = 65981, + [SMALL_STATE(1104)] = 66006, + [SMALL_STATE(1105)] = 66033, + [SMALL_STATE(1106)] = 66058, + [SMALL_STATE(1107)] = 66085, + [SMALL_STATE(1108)] = 66112, + [SMALL_STATE(1109)] = 66137, + [SMALL_STATE(1110)] = 66164, + [SMALL_STATE(1111)] = 66191, + [SMALL_STATE(1112)] = 66218, + [SMALL_STATE(1113)] = 66245, + [SMALL_STATE(1114)] = 66270, + [SMALL_STATE(1115)] = 66309, + [SMALL_STATE(1116)] = 66334, + [SMALL_STATE(1117)] = 66361, + [SMALL_STATE(1118)] = 66386, + [SMALL_STATE(1119)] = 66413, + [SMALL_STATE(1120)] = 66438, + [SMALL_STATE(1121)] = 66465, + [SMALL_STATE(1122)] = 66490, + [SMALL_STATE(1123)] = 66515, + [SMALL_STATE(1124)] = 66542, + [SMALL_STATE(1125)] = 66569, + [SMALL_STATE(1126)] = 66596, + [SMALL_STATE(1127)] = 66623, + [SMALL_STATE(1128)] = 66650, + [SMALL_STATE(1129)] = 66677, + [SMALL_STATE(1130)] = 66704, + [SMALL_STATE(1131)] = 66729, + [SMALL_STATE(1132)] = 66756, + [SMALL_STATE(1133)] = 66783, + [SMALL_STATE(1134)] = 66822, + [SMALL_STATE(1135)] = 66863, + [SMALL_STATE(1136)] = 66902, + [SMALL_STATE(1137)] = 66927, + [SMALL_STATE(1138)] = 66954, + [SMALL_STATE(1139)] = 66981, + [SMALL_STATE(1140)] = 67008, + [SMALL_STATE(1141)] = 67035, + [SMALL_STATE(1142)] = 67062, + [SMALL_STATE(1143)] = 67087, + [SMALL_STATE(1144)] = 67114, + [SMALL_STATE(1145)] = 67139, + [SMALL_STATE(1146)] = 67164, + [SMALL_STATE(1147)] = 67189, + [SMALL_STATE(1148)] = 67216, + [SMALL_STATE(1149)] = 67241, + [SMALL_STATE(1150)] = 67266, + [SMALL_STATE(1151)] = 67293, + [SMALL_STATE(1152)] = 67318, + [SMALL_STATE(1153)] = 67345, + [SMALL_STATE(1154)] = 67370, + [SMALL_STATE(1155)] = 67409, + [SMALL_STATE(1156)] = 67436, + [SMALL_STATE(1157)] = 67461, + [SMALL_STATE(1158)] = 67488, + [SMALL_STATE(1159)] = 67513, + [SMALL_STATE(1160)] = 67540, + [SMALL_STATE(1161)] = 67565, + [SMALL_STATE(1162)] = 67592, + [SMALL_STATE(1163)] = 67617, + [SMALL_STATE(1164)] = 67644, + [SMALL_STATE(1165)] = 67669, + [SMALL_STATE(1166)] = 67694, + [SMALL_STATE(1167)] = 67721, + [SMALL_STATE(1168)] = 67746, + [SMALL_STATE(1169)] = 67771, + [SMALL_STATE(1170)] = 67796, + [SMALL_STATE(1171)] = 67821, + [SMALL_STATE(1172)] = 67846, + [SMALL_STATE(1173)] = 67873, + [SMALL_STATE(1174)] = 67900, + [SMALL_STATE(1175)] = 67927, + [SMALL_STATE(1176)] = 67966, + [SMALL_STATE(1177)] = 67993, + [SMALL_STATE(1178)] = 68032, + [SMALL_STATE(1179)] = 68057, + [SMALL_STATE(1180)] = 68084, + [SMALL_STATE(1181)] = 68111, + [SMALL_STATE(1182)] = 68138, + [SMALL_STATE(1183)] = 68165, + [SMALL_STATE(1184)] = 68192, + [SMALL_STATE(1185)] = 68219, + [SMALL_STATE(1186)] = 68246, + [SMALL_STATE(1187)] = 68271, + [SMALL_STATE(1188)] = 68298, + [SMALL_STATE(1189)] = 68325, + [SMALL_STATE(1190)] = 68350, + [SMALL_STATE(1191)] = 68377, + [SMALL_STATE(1192)] = 68404, + [SMALL_STATE(1193)] = 68429, + [SMALL_STATE(1194)] = 68456, + [SMALL_STATE(1195)] = 68483, + [SMALL_STATE(1196)] = 68508, + [SMALL_STATE(1197)] = 68546, + [SMALL_STATE(1198)] = 68582, + [SMALL_STATE(1199)] = 68620, + [SMALL_STATE(1200)] = 68656, + [SMALL_STATE(1201)] = 68692, + [SMALL_STATE(1202)] = 68728, + [SMALL_STATE(1203)] = 68764, + [SMALL_STATE(1204)] = 68796, + [SMALL_STATE(1205)] = 68832, + [SMALL_STATE(1206)] = 68870, + [SMALL_STATE(1207)] = 68906, + [SMALL_STATE(1208)] = 68942, + [SMALL_STATE(1209)] = 68980, + [SMALL_STATE(1210)] = 69013, + [SMALL_STATE(1211)] = 69040, + [SMALL_STATE(1212)] = 69071, + [SMALL_STATE(1213)] = 69104, + [SMALL_STATE(1214)] = 69137, + [SMALL_STATE(1215)] = 69170, + [SMALL_STATE(1216)] = 69203, + [SMALL_STATE(1217)] = 69232, + [SMALL_STATE(1218)] = 69263, + [SMALL_STATE(1219)] = 69296, + [SMALL_STATE(1220)] = 69331, + [SMALL_STATE(1221)] = 69362, + [SMALL_STATE(1222)] = 69394, + [SMALL_STATE(1223)] = 69422, + [SMALL_STATE(1224)] = 69452, + [SMALL_STATE(1225)] = 69482, + [SMALL_STATE(1226)] = 69512, + [SMALL_STATE(1227)] = 69544, + [SMALL_STATE(1228)] = 69574, + [SMALL_STATE(1229)] = 69606, + [SMALL_STATE(1230)] = 69638, + [SMALL_STATE(1231)] = 69670, + [SMALL_STATE(1232)] = 69702, + [SMALL_STATE(1233)] = 69734, + [SMALL_STATE(1234)] = 69766, + [SMALL_STATE(1235)] = 69795, + [SMALL_STATE(1236)] = 69822, + [SMALL_STATE(1237)] = 69845, + [SMALL_STATE(1238)] = 69874, + [SMALL_STATE(1239)] = 69901, + [SMALL_STATE(1240)] = 69922, + [SMALL_STATE(1241)] = 69951, + [SMALL_STATE(1242)] = 69978, + [SMALL_STATE(1243)] = 70005, + [SMALL_STATE(1244)] = 70034, + [SMALL_STATE(1245)] = 70061, + [SMALL_STATE(1246)] = 70090, + [SMALL_STATE(1247)] = 70117, + [SMALL_STATE(1248)] = 70146, + [SMALL_STATE(1249)] = 70170, + [SMALL_STATE(1250)] = 70196, + [SMALL_STATE(1251)] = 70222, + [SMALL_STATE(1252)] = 70244, + [SMALL_STATE(1253)] = 70270, + [SMALL_STATE(1254)] = 70296, + [SMALL_STATE(1255)] = 70320, + [SMALL_STATE(1256)] = 70346, + [SMALL_STATE(1257)] = 70372, + [SMALL_STATE(1258)] = 70398, + [SMALL_STATE(1259)] = 70424, + [SMALL_STATE(1260)] = 70450, + [SMALL_STATE(1261)] = 70474, + [SMALL_STATE(1262)] = 70500, + [SMALL_STATE(1263)] = 70526, + [SMALL_STATE(1264)] = 70552, + [SMALL_STATE(1265)] = 70578, + [SMALL_STATE(1266)] = 70604, + [SMALL_STATE(1267)] = 70630, + [SMALL_STATE(1268)] = 70654, + [SMALL_STATE(1269)] = 70678, + [SMALL_STATE(1270)] = 70704, + [SMALL_STATE(1271)] = 70730, + [SMALL_STATE(1272)] = 70756, + [SMALL_STATE(1273)] = 70782, + [SMALL_STATE(1274)] = 70808, + [SMALL_STATE(1275)] = 70834, + [SMALL_STATE(1276)] = 70860, + [SMALL_STATE(1277)] = 70886, + [SMALL_STATE(1278)] = 70912, + [SMALL_STATE(1279)] = 70938, + [SMALL_STATE(1280)] = 70964, + [SMALL_STATE(1281)] = 70990, + [SMALL_STATE(1282)] = 71016, + [SMALL_STATE(1283)] = 71042, + [SMALL_STATE(1284)] = 71068, + [SMALL_STATE(1285)] = 71092, + [SMALL_STATE(1286)] = 71118, + [SMALL_STATE(1287)] = 71142, + [SMALL_STATE(1288)] = 71168, + [SMALL_STATE(1289)] = 71189, + [SMALL_STATE(1290)] = 71210, + [SMALL_STATE(1291)] = 71233, + [SMALL_STATE(1292)] = 71256, + [SMALL_STATE(1293)] = 71279, + [SMALL_STATE(1294)] = 71302, + [SMALL_STATE(1295)] = 71325, + [SMALL_STATE(1296)] = 71346, + [SMALL_STATE(1297)] = 71369, + [SMALL_STATE(1298)] = 71392, + [SMALL_STATE(1299)] = 71413, + [SMALL_STATE(1300)] = 71436, + [SMALL_STATE(1301)] = 71457, + [SMALL_STATE(1302)] = 71478, + [SMALL_STATE(1303)] = 71501, + [SMALL_STATE(1304)] = 71522, + [SMALL_STATE(1305)] = 71543, + [SMALL_STATE(1306)] = 71564, + [SMALL_STATE(1307)] = 71585, + [SMALL_STATE(1308)] = 71608, + [SMALL_STATE(1309)] = 71629, + [SMALL_STATE(1310)] = 71652, + [SMALL_STATE(1311)] = 71673, + [SMALL_STATE(1312)] = 71694, + [SMALL_STATE(1313)] = 71717, + [SMALL_STATE(1314)] = 71738, + [SMALL_STATE(1315)] = 71761, + [SMALL_STATE(1316)] = 71784, + [SMALL_STATE(1317)] = 71805, + [SMALL_STATE(1318)] = 71828, + [SMALL_STATE(1319)] = 71849, + [SMALL_STATE(1320)] = 71872, + [SMALL_STATE(1321)] = 71895, + [SMALL_STATE(1322)] = 71916, + [SMALL_STATE(1323)] = 71937, + [SMALL_STATE(1324)] = 71958, + [SMALL_STATE(1325)] = 71979, + [SMALL_STATE(1326)] = 72002, + [SMALL_STATE(1327)] = 72025, + [SMALL_STATE(1328)] = 72046, + [SMALL_STATE(1329)] = 72067, + [SMALL_STATE(1330)] = 72088, + [SMALL_STATE(1331)] = 72109, + [SMALL_STATE(1332)] = 72130, + [SMALL_STATE(1333)] = 72153, + [SMALL_STATE(1334)] = 72174, + [SMALL_STATE(1335)] = 72195, + [SMALL_STATE(1336)] = 72218, + [SMALL_STATE(1337)] = 72241, + [SMALL_STATE(1338)] = 72262, + [SMALL_STATE(1339)] = 72283, + [SMALL_STATE(1340)] = 72304, + [SMALL_STATE(1341)] = 72327, + [SMALL_STATE(1342)] = 72350, + [SMALL_STATE(1343)] = 72373, + [SMALL_STATE(1344)] = 72394, + [SMALL_STATE(1345)] = 72417, + [SMALL_STATE(1346)] = 72438, + [SMALL_STATE(1347)] = 72461, + [SMALL_STATE(1348)] = 72484, + [SMALL_STATE(1349)] = 72507, + [SMALL_STATE(1350)] = 72528, + [SMALL_STATE(1351)] = 72551, + [SMALL_STATE(1352)] = 72572, + [SMALL_STATE(1353)] = 72593, + [SMALL_STATE(1354)] = 72614, + [SMALL_STATE(1355)] = 72637, + [SMALL_STATE(1356)] = 72660, + [SMALL_STATE(1357)] = 72683, + [SMALL_STATE(1358)] = 72704, + [SMALL_STATE(1359)] = 72725, + [SMALL_STATE(1360)] = 72748, + [SMALL_STATE(1361)] = 72769, + [SMALL_STATE(1362)] = 72790, + [SMALL_STATE(1363)] = 72813, + [SMALL_STATE(1364)] = 72834, + [SMALL_STATE(1365)] = 72857, + [SMALL_STATE(1366)] = 72878, + [SMALL_STATE(1367)] = 72899, + [SMALL_STATE(1368)] = 72920, + [SMALL_STATE(1369)] = 72941, + [SMALL_STATE(1370)] = 72964, + [SMALL_STATE(1371)] = 72985, + [SMALL_STATE(1372)] = 73008, + [SMALL_STATE(1373)] = 73029, + [SMALL_STATE(1374)] = 73052, + [SMALL_STATE(1375)] = 73075, + [SMALL_STATE(1376)] = 73098, + [SMALL_STATE(1377)] = 73121, + [SMALL_STATE(1378)] = 73142, + [SMALL_STATE(1379)] = 73163, + [SMALL_STATE(1380)] = 73186, + [SMALL_STATE(1381)] = 73207, + [SMALL_STATE(1382)] = 73228, + [SMALL_STATE(1383)] = 73251, + [SMALL_STATE(1384)] = 73272, + [SMALL_STATE(1385)] = 73293, + [SMALL_STATE(1386)] = 73314, + [SMALL_STATE(1387)] = 73337, + [SMALL_STATE(1388)] = 73358, + [SMALL_STATE(1389)] = 73379, + [SMALL_STATE(1390)] = 73402, + [SMALL_STATE(1391)] = 73423, + [SMALL_STATE(1392)] = 73446, + [SMALL_STATE(1393)] = 73467, + [SMALL_STATE(1394)] = 73490, + [SMALL_STATE(1395)] = 73511, + [SMALL_STATE(1396)] = 73534, + [SMALL_STATE(1397)] = 73555, + [SMALL_STATE(1398)] = 73578, + [SMALL_STATE(1399)] = 73599, + [SMALL_STATE(1400)] = 73620, + [SMALL_STATE(1401)] = 73643, + [SMALL_STATE(1402)] = 73666, + [SMALL_STATE(1403)] = 73687, + [SMALL_STATE(1404)] = 73710, + [SMALL_STATE(1405)] = 73733, + [SMALL_STATE(1406)] = 73754, + [SMALL_STATE(1407)] = 73775, + [SMALL_STATE(1408)] = 73798, + [SMALL_STATE(1409)] = 73821, + [SMALL_STATE(1410)] = 73842, + [SMALL_STATE(1411)] = 73863, + [SMALL_STATE(1412)] = 73884, + [SMALL_STATE(1413)] = 73905, + [SMALL_STATE(1414)] = 73928, + [SMALL_STATE(1415)] = 73948, + [SMALL_STATE(1416)] = 73968, + [SMALL_STATE(1417)] = 73988, + [SMALL_STATE(1418)] = 74008, + [SMALL_STATE(1419)] = 74028, + [SMALL_STATE(1420)] = 74048, + [SMALL_STATE(1421)] = 74068, + [SMALL_STATE(1422)] = 74088, + [SMALL_STATE(1423)] = 74108, + [SMALL_STATE(1424)] = 74128, + [SMALL_STATE(1425)] = 74148, + [SMALL_STATE(1426)] = 74168, + [SMALL_STATE(1427)] = 74188, + [SMALL_STATE(1428)] = 74208, + [SMALL_STATE(1429)] = 74228, + [SMALL_STATE(1430)] = 74248, + [SMALL_STATE(1431)] = 74268, + [SMALL_STATE(1432)] = 74288, + [SMALL_STATE(1433)] = 74308, + [SMALL_STATE(1434)] = 74328, + [SMALL_STATE(1435)] = 74348, + [SMALL_STATE(1436)] = 74368, + [SMALL_STATE(1437)] = 74388, + [SMALL_STATE(1438)] = 74408, + [SMALL_STATE(1439)] = 74428, + [SMALL_STATE(1440)] = 74448, + [SMALL_STATE(1441)] = 74468, + [SMALL_STATE(1442)] = 74488, + [SMALL_STATE(1443)] = 74508, + [SMALL_STATE(1444)] = 74528, + [SMALL_STATE(1445)] = 74548, + [SMALL_STATE(1446)] = 74568, + [SMALL_STATE(1447)] = 74586, + [SMALL_STATE(1448)] = 74606, + [SMALL_STATE(1449)] = 74626, + [SMALL_STATE(1450)] = 74646, + [SMALL_STATE(1451)] = 74663, + [SMALL_STATE(1452)] = 74680, + [SMALL_STATE(1453)] = 74697, + [SMALL_STATE(1454)] = 74714, + [SMALL_STATE(1455)] = 74731, + [SMALL_STATE(1456)] = 74748, + [SMALL_STATE(1457)] = 74765, + [SMALL_STATE(1458)] = 74782, + [SMALL_STATE(1459)] = 74799, + [SMALL_STATE(1460)] = 74816, + [SMALL_STATE(1461)] = 74833, + [SMALL_STATE(1462)] = 74850, + [SMALL_STATE(1463)] = 74867, + [SMALL_STATE(1464)] = 74884, + [SMALL_STATE(1465)] = 74901, + [SMALL_STATE(1466)] = 74918, + [SMALL_STATE(1467)] = 74935, + [SMALL_STATE(1468)] = 74952, + [SMALL_STATE(1469)] = 74969, + [SMALL_STATE(1470)] = 74986, + [SMALL_STATE(1471)] = 75003, + [SMALL_STATE(1472)] = 75020, + [SMALL_STATE(1473)] = 75037, + [SMALL_STATE(1474)] = 75054, + [SMALL_STATE(1475)] = 75071, + [SMALL_STATE(1476)] = 75088, + [SMALL_STATE(1477)] = 75105, + [SMALL_STATE(1478)] = 75122, + [SMALL_STATE(1479)] = 75139, + [SMALL_STATE(1480)] = 75156, + [SMALL_STATE(1481)] = 75173, + [SMALL_STATE(1482)] = 75190, + [SMALL_STATE(1483)] = 75207, + [SMALL_STATE(1484)] = 75224, + [SMALL_STATE(1485)] = 75241, + [SMALL_STATE(1486)] = 75258, + [SMALL_STATE(1487)] = 75275, + [SMALL_STATE(1488)] = 75292, + [SMALL_STATE(1489)] = 75309, + [SMALL_STATE(1490)] = 75326, + [SMALL_STATE(1491)] = 75343, + [SMALL_STATE(1492)] = 75360, + [SMALL_STATE(1493)] = 75377, + [SMALL_STATE(1494)] = 75394, + [SMALL_STATE(1495)] = 75411, + [SMALL_STATE(1496)] = 75428, + [SMALL_STATE(1497)] = 75445, + [SMALL_STATE(1498)] = 75462, + [SMALL_STATE(1499)] = 75479, + [SMALL_STATE(1500)] = 75496, + [SMALL_STATE(1501)] = 75513, + [SMALL_STATE(1502)] = 75530, + [SMALL_STATE(1503)] = 75547, + [SMALL_STATE(1504)] = 75564, + [SMALL_STATE(1505)] = 75581, + [SMALL_STATE(1506)] = 75598, + [SMALL_STATE(1507)] = 75615, + [SMALL_STATE(1508)] = 75632, + [SMALL_STATE(1509)] = 75649, + [SMALL_STATE(1510)] = 75666, + [SMALL_STATE(1511)] = 75683, + [SMALL_STATE(1512)] = 75700, + [SMALL_STATE(1513)] = 75717, + [SMALL_STATE(1514)] = 75734, + [SMALL_STATE(1515)] = 75751, + [SMALL_STATE(1516)] = 75768, + [SMALL_STATE(1517)] = 75785, + [SMALL_STATE(1518)] = 75802, + [SMALL_STATE(1519)] = 75819, + [SMALL_STATE(1520)] = 75836, + [SMALL_STATE(1521)] = 75853, + [SMALL_STATE(1522)] = 75870, + [SMALL_STATE(1523)] = 75887, + [SMALL_STATE(1524)] = 75904, + [SMALL_STATE(1525)] = 75921, + [SMALL_STATE(1526)] = 75938, + [SMALL_STATE(1527)] = 75955, + [SMALL_STATE(1528)] = 75972, + [SMALL_STATE(1529)] = 75989, + [SMALL_STATE(1530)] = 76006, + [SMALL_STATE(1531)] = 76023, + [SMALL_STATE(1532)] = 76040, + [SMALL_STATE(1533)] = 76057, + [SMALL_STATE(1534)] = 76074, + [SMALL_STATE(1535)] = 76091, + [SMALL_STATE(1536)] = 76108, + [SMALL_STATE(1537)] = 76125, + [SMALL_STATE(1538)] = 76142, + [SMALL_STATE(1539)] = 76159, + [SMALL_STATE(1540)] = 76176, + [SMALL_STATE(1541)] = 76193, + [SMALL_STATE(1542)] = 76210, + [SMALL_STATE(1543)] = 76227, + [SMALL_STATE(1544)] = 76244, + [SMALL_STATE(1545)] = 76261, + [SMALL_STATE(1546)] = 76278, + [SMALL_STATE(1547)] = 76295, + [SMALL_STATE(1548)] = 76312, + [SMALL_STATE(1549)] = 76329, + [SMALL_STATE(1550)] = 76346, + [SMALL_STATE(1551)] = 76363, + [SMALL_STATE(1552)] = 76380, + [SMALL_STATE(1553)] = 76397, + [SMALL_STATE(1554)] = 76414, + [SMALL_STATE(1555)] = 76431, + [SMALL_STATE(1556)] = 76448, + [SMALL_STATE(1557)] = 76465, + [SMALL_STATE(1558)] = 76482, + [SMALL_STATE(1559)] = 76499, + [SMALL_STATE(1560)] = 76516, + [SMALL_STATE(1561)] = 76533, + [SMALL_STATE(1562)] = 76550, + [SMALL_STATE(1563)] = 76567, + [SMALL_STATE(1564)] = 76584, + [SMALL_STATE(1565)] = 76601, + [SMALL_STATE(1566)] = 76618, + [SMALL_STATE(1567)] = 76635, + [SMALL_STATE(1568)] = 76652, + [SMALL_STATE(1569)] = 76669, + [SMALL_STATE(1570)] = 76686, + [SMALL_STATE(1571)] = 76703, + [SMALL_STATE(1572)] = 76720, + [SMALL_STATE(1573)] = 76737, + [SMALL_STATE(1574)] = 76754, + [SMALL_STATE(1575)] = 76771, + [SMALL_STATE(1576)] = 76788, + [SMALL_STATE(1577)] = 76805, + [SMALL_STATE(1578)] = 76822, + [SMALL_STATE(1579)] = 76839, + [SMALL_STATE(1580)] = 76856, + [SMALL_STATE(1581)] = 76873, + [SMALL_STATE(1582)] = 76890, + [SMALL_STATE(1583)] = 76907, + [SMALL_STATE(1584)] = 76924, + [SMALL_STATE(1585)] = 76941, + [SMALL_STATE(1586)] = 76958, + [SMALL_STATE(1587)] = 76975, + [SMALL_STATE(1588)] = 76992, + [SMALL_STATE(1589)] = 77009, + [SMALL_STATE(1590)] = 77026, + [SMALL_STATE(1591)] = 77043, + [SMALL_STATE(1592)] = 77060, + [SMALL_STATE(1593)] = 77077, + [SMALL_STATE(1594)] = 77094, + [SMALL_STATE(1595)] = 77111, + [SMALL_STATE(1596)] = 77128, + [SMALL_STATE(1597)] = 77145, + [SMALL_STATE(1598)] = 77162, + [SMALL_STATE(1599)] = 77179, + [SMALL_STATE(1600)] = 77196, + [SMALL_STATE(1601)] = 77213, + [SMALL_STATE(1602)] = 77230, + [SMALL_STATE(1603)] = 77247, + [SMALL_STATE(1604)] = 77264, + [SMALL_STATE(1605)] = 77281, + [SMALL_STATE(1606)] = 77298, + [SMALL_STATE(1607)] = 77315, + [SMALL_STATE(1608)] = 77332, + [SMALL_STATE(1609)] = 77349, + [SMALL_STATE(1610)] = 77366, + [SMALL_STATE(1611)] = 77383, + [SMALL_STATE(1612)] = 77400, + [SMALL_STATE(1613)] = 77417, + [SMALL_STATE(1614)] = 77434, + [SMALL_STATE(1615)] = 77451, + [SMALL_STATE(1616)] = 77468, + [SMALL_STATE(1617)] = 77485, + [SMALL_STATE(1618)] = 77502, + [SMALL_STATE(1619)] = 77519, + [SMALL_STATE(1620)] = 77536, + [SMALL_STATE(1621)] = 77553, + [SMALL_STATE(1622)] = 77570, + [SMALL_STATE(1623)] = 77587, + [SMALL_STATE(1624)] = 77604, + [SMALL_STATE(1625)] = 77621, + [SMALL_STATE(1626)] = 77638, + [SMALL_STATE(1627)] = 77655, + [SMALL_STATE(1628)] = 77672, + [SMALL_STATE(1629)] = 77689, + [SMALL_STATE(1630)] = 77706, + [SMALL_STATE(1631)] = 77723, + [SMALL_STATE(1632)] = 77740, + [SMALL_STATE(1633)] = 77757, + [SMALL_STATE(1634)] = 77774, + [SMALL_STATE(1635)] = 77791, + [SMALL_STATE(1636)] = 77808, + [SMALL_STATE(1637)] = 77812, + [SMALL_STATE(1638)] = 77816, + [SMALL_STATE(1639)] = 77820, + [SMALL_STATE(1640)] = 77824, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1255), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [9] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 0, 0, 0), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(760), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1177), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(54), + [35] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 2, 0, 0), SHIFT(1445), + [38] = {.entry = {.count = 1, .reusable = false}}, SHIFT(20), + [40] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_instr, 2, 0, 0), + [42] = {.entry = {.count = 1, .reusable = false}}, SHIFT(25), + [44] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [46] = {.entry = {.count = 1, .reusable = false}}, SHIFT(30), + [48] = {.entry = {.count = 1, .reusable = false}}, SHIFT(28), + [50] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [52] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [54] = {.entry = {.count = 1, .reusable = false}}, SHIFT(23), + [56] = {.entry = {.count = 1, .reusable = false}}, SHIFT(24), + [58] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 1, 0, 0), SHIFT(1445), + [63] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_instr, 1, 0, 0), + [65] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), + [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [71] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(1445), + [74] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(20), + [77] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), + [79] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(25), + [82] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(21), + [85] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(30), + [88] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(28), + [91] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(28), + [94] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(30), + [97] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(23), + [100] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(24), + [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1117), + [105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), + [109] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 1, 0, 0), SHIFT(1442), + [112] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), + [114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), + [116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), + [120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), + [122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [126] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), + [128] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [130] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(1423), + [133] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(51), + [136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), + [138] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(46), + [141] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(33), + [144] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(39), + [147] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(40), + [150] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(40), + [153] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(39), + [156] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(41), + [159] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(47), + [162] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 2, 0, 0), SHIFT(1423), + [165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [167] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_instr, 2, 0, 0), + [169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(39), + [175] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), + [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47), + [185] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 2, 0, 0), SHIFT(1442), + [188] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(1442), + [191] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(34), + [194] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(48), + [197] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(35), + [200] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(36), + [203] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(37), + [206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(37), + [209] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(36), + [212] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(31), + [215] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(43), + [218] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_plain_instr, 1, 0, 0), SHIFT(1423), + [221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_instr, 1, 0, 0), + [223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(1447), + [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(61), + [229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(61), + [232] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(60), + [235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(56), + [238] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(57), + [241] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(58), + [244] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(57), + [247] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(59), + [250] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 2, 0, 0), SHIFT_REPEAT(54), + [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_heap_type, 1, 0, 0), + [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_heap_type, 1, 0, 0), + [257] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__immediate, 1, 0, 0), REDUCE(sym_index, 1, 0, 0), + [260] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__immediate, 1, 0, 0), REDUCE(sym_index, 1, 0, 0), + [263] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_plain_instr_repeat1, 1, 0, 0), + [265] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_plain_instr_repeat1, 1, 0, 0), + [267] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shape_descriptor, 1, 0, 0), + [269] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shape_descriptor, 1, 0, 0), + [271] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 1, 0, 0), + [273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 1, 0, 0), + [275] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ref_type, 1, 0, 0), + [277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ref_type, 1, 0, 0), + [279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ref_type, 4, 0, 0), + [281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ref_type, 4, 0, 0), + [283] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ref_type, 5, 0, 0), + [285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ref_type, 5, 0, 0), + [287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_float, 1, 0, 0), + [289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_float, 1, 0, 0), + [291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_clause, 5, 0, 0), + [293] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_clause, 5, 0, 0), + [295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__immediate, 1, 0, 0), + [297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__immediate, 1, 0, 0), + [299] = {.entry = {.count = 1, .reusable = false}}, SHIFT(765), + [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1357), + [303] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), + [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71), + [307] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), + [309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(73), + [311] = {.entry = {.count = 1, .reusable = false}}, SHIFT(744), + [313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [315] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), + [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(997), + [319] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_index, 1, 0, 0), SHIFT(1351), + [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1238), + [324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(597), + [326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1174), + [328] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_index, 1, 0, 0), SHIFT(1236), + [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1329), + [333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), + [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), + [337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), + [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1236), + [343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1000), + [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), + [347] = {.entry = {.count = 1, .reusable = false}}, SHIFT(802), + [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70), + [351] = {.entry = {.count = 1, .reusable = false}}, SHIFT(469), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145), + [355] = {.entry = {.count = 1, .reusable = false}}, SHIFT(80), + [357] = {.entry = {.count = 1, .reusable = false}}, SHIFT(736), + [359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(5), + [363] = {.entry = {.count = 1, .reusable = false}}, SHIFT(914), + [365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [367] = {.entry = {.count = 1, .reusable = false}}, SHIFT(884), + [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(755), + [373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(129), + [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(950), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72), + [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(130), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(748), + [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(13), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(759), + [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), + [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1444), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1448), + [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(640), + [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(518), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [409] = {.entry = {.count = 1, .reusable = false}}, SHIFT(886), + [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1013), + [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(963), + [419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(691), + [421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [423] = {.entry = {.count = 1, .reusable = false}}, SHIFT(804), + [425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [431] = {.entry = {.count = 1, .reusable = false}}, SHIFT(807), + [433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(844), + [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(832), + [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1175), + [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(980), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(971), + [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(846), + [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(850), + [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(692), + [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(874), + [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(809), + [457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1108), + [459] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), SHIFT_REPEAT(656), + [462] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), SHIFT_REPEAT(1444), + [465] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), + [467] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), SHIFT_REPEAT(640), + [470] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), SHIFT_REPEAT(523), + [473] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 2, 0, 0), SHIFT_REPEAT(518), + [476] = {.entry = {.count = 1, .reusable = false}}, SHIFT(814), + [478] = {.entry = {.count = 1, .reusable = false}}, SHIFT(819), + [480] = {.entry = {.count = 1, .reusable = false}}, SHIFT(965), + [482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), + [484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), + [486] = {.entry = {.count = 1, .reusable = false}}, SHIFT(949), + [488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(680), + [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [492] = {.entry = {.count = 1, .reusable = false}}, SHIFT(840), + [494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [496] = {.entry = {.count = 1, .reusable = false}}, SHIFT(762), + [498] = {.entry = {.count = 1, .reusable = false}}, SHIFT(962), + [500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), + [502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [506] = {.entry = {.count = 1, .reusable = false}}, SHIFT(875), + [508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(948), + [510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [512] = {.entry = {.count = 1, .reusable = false}}, SHIFT(876), + [514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [516] = {.entry = {.count = 1, .reusable = false}}, SHIFT(770), + [518] = {.entry = {.count = 1, .reusable = false}}, SHIFT(969), + [520] = {.entry = {.count = 1, .reusable = false}}, SHIFT(882), + [522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [524] = {.entry = {.count = 1, .reusable = false}}, SHIFT(885), + [526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1180), + [530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), + [534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [538] = {.entry = {.count = 1, .reusable = false}}, SHIFT(848), + [540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [542] = {.entry = {.count = 1, .reusable = false}}, SHIFT(852), + [544] = {.entry = {.count = 1, .reusable = false}}, SHIFT(801), + [546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(803), + [550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [552] = {.entry = {.count = 1, .reusable = false}}, SHIFT(984), + [554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), + [560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), + [566] = {.entry = {.count = 1, .reusable = false}}, SHIFT(816), + [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), + [570] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), + [572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), + [574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), + [576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), + [580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1360), + [584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), + [586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), + [594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), + [596] = {.entry = {.count = 1, .reusable = false}}, SHIFT(955), + [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1102), + [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), + [602] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1204), + [604] = {.entry = {.count = 1, .reusable = false}}, SHIFT(967), + [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [608] = {.entry = {.count = 1, .reusable = false}}, SHIFT(854), + [610] = {.entry = {.count = 1, .reusable = false}}, SHIFT(822), + [612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1094), + [614] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1276), + [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), + [618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [622] = {.entry = {.count = 1, .reusable = false}}, SHIFT(992), + [624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), + [626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), + [628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [630] = {.entry = {.count = 1, .reusable = false}}, SHIFT(893), + [632] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1443), + [634] = {.entry = {.count = 1, .reusable = false}}, SHIFT(806), + [636] = {.entry = {.count = 1, .reusable = false}}, SHIFT(808), + [638] = {.entry = {.count = 1, .reusable = false}}, SHIFT(863), + [640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1154), + [642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), + [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), + [646] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1114), + [648] = {.entry = {.count = 1, .reusable = false}}, SHIFT(778), + [650] = {.entry = {.count = 1, .reusable = false}}, SHIFT(773), + [652] = {.entry = {.count = 1, .reusable = false}}, SHIFT(849), + [654] = {.entry = {.count = 1, .reusable = false}}, SHIFT(851), + [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [660] = {.entry = {.count = 1, .reusable = false}}, SHIFT(856), + [662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), + [664] = {.entry = {.count = 1, .reusable = false}}, SHIFT(983), + [666] = {.entry = {.count = 1, .reusable = false}}, SHIFT(956), + [668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(704), + [670] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1544), + [672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(708), + [674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(698), + [676] = {.entry = {.count = 1, .reusable = false}}, SHIFT(813), + [678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), + [680] = {.entry = {.count = 1, .reusable = false}}, SHIFT(815), + [682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1394), + [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1136), + [686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), + [688] = {.entry = {.count = 1, .reusable = false}}, SHIFT(818), + [690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [692] = {.entry = {.count = 1, .reusable = false}}, SHIFT(820), + [694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), + [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), + [698] = {.entry = {.count = 1, .reusable = false}}, SHIFT(964), + [700] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), + [702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), + [704] = {.entry = {.count = 1, .reusable = false}}, SHIFT(994), + [706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(845), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), + [710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(979), + [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [714] = {.entry = {.count = 1, .reusable = false}}, SHIFT(968), + [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), + [720] = {.entry = {.count = 1, .reusable = false}}, SHIFT(847), + [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(940), + [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1172), + [726] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1552), + [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1157), + [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(552), + [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(642), + [736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1185), + [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(535), + [744] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1199), + [746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1093), + [748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1201), + [750] = {.entry = {.count = 1, .reusable = false}}, SHIFT(841), + [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), + [754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1109), + [756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [758] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1202), + [760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(811), + [762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), + [766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1156), + [768] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_local_repeat1, 2, 0, 0), SHIFT_REPEAT(656), + [771] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_local_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), + [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_local_repeat1, 2, 0, 0), + [776] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_local_repeat1, 2, 0, 0), SHIFT_REPEAT(523), + [779] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_local_repeat1, 2, 0, 0), SHIFT_REPEAT(518), + [782] = {.entry = {.count = 1, .reusable = false}}, SHIFT(853), + [784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(855), + [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), + [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1131), + [790] = {.entry = {.count = 1, .reusable = false}}, SHIFT(860), + [792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), + [794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), + [796] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1424), + [798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), + [800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), + [802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), + [804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), + [806] = {.entry = {.count = 1, .reusable = false}}, SHIFT(991), + [808] = {.entry = {.count = 1, .reusable = false}}, SHIFT(993), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), + [812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1408), + [814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(725), + [818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(821), + [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(681), + [822] = {.entry = {.count = 1, .reusable = false}}, SHIFT(823), + [824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1186), + [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [828] = {.entry = {.count = 1, .reusable = false}}, SHIFT(828), + [830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), + [832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), + [834] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1006), + [836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), + [842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(697), + [844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [846] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1218), + [848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if_then, 1, 0, 0), + [850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1213), + [852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if_else, 1, 0, 0), + [854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), + [856] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(1218), + [859] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(144), + [862] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), + [864] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(70), + [867] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(145), + [870] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(80), + [873] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(736), + [876] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(5), + [879] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(1209), + [882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), + [884] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(120), + [887] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(71), + [890] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(119), + [893] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(73), + [896] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(744), + [899] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(18), + [902] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1209), + [904] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_type, 1, 0, 0), + [906] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_type, 1, 0, 0), + [908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), + [910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), + [912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if_else, 2, 0, 0), + [914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [916] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1200), + [918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), + [920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), + [924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), + [926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), + [928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1380), + [930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1295), + [934] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__value_type, 1, 0, 0), + [936] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__value_type, 1, 0, 0), + [938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1366), + [942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), + [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [946] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(1213), + [949] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(129), + [952] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(72), + [955] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(130), + [958] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(76), + [961] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(748), + [964] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 2, 0, 0), SHIFT_REPEAT(13), + [967] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_repeat1, 1, 0, 0), + [969] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_field_repeat1, 1, 0, 0), + [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [973] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_field_func_repeat1, 2, 0, 0), + [975] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat1, 2, 0, 0), SHIFT_REPEAT(1569), + [978] = {.entry = {.count = 1, .reusable = false}}, SHIFT(825), + [980] = {.entry = {.count = 1, .reusable = false}}, SHIFT(827), + [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), + [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), + [992] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1003), + [994] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1005), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1399), + [1000] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_type, 4, 0, 0), + [1002] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_type, 4, 0, 0), + [1004] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if_else, 3, 0, 0), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(690), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(696), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), + [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(944), + [1014] = {.entry = {.count = 1, .reusable = false}}, SHIFT(857), + [1016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(946), + [1018] = {.entry = {.count = 1, .reusable = false}}, SHIFT(859), + [1020] = {.entry = {.count = 1, .reusable = false}}, SHIFT(931), + [1022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [1024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1016), + [1026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), + [1028] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_packed_type, 1, 0, 0), + [1030] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_packed_type, 1, 0, 0), + [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), + [1034] = {.entry = {.count = 1, .reusable = false}}, SHIFT(862), + [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), + [1038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), + [1040] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__storage_type, 1, 0, 0), + [1042] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__storage_type, 1, 0, 0), + [1044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_num_type, 1, 0, 0), + [1046] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_num_type, 1, 0, 0), + [1048] = {.entry = {.count = 1, .reusable = false}}, SHIFT(830), + [1050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_field_func_repeat1, 1, 0, 0), + [1052] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat1, 1, 0, 0), + [1054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export, 4, 0, 0), + [1056] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_export, 4, 0, 0), + [1058] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import, 5, 0, 0), + [1060] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import, 5, 0, 0), + [1062] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_local_repeat1, 1, 0, 0), + [1064] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_local_repeat1, 1, 0, 0), + [1066] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr_folded, 1, 0, 5), + [1068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr_folded, 1, 0, 5), + [1070] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__plain_instr_folded, 4, 0, 0), + [1072] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__plain_instr_folded, 4, 0, 0), + [1074] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 6, 0, 0), + [1076] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 6, 0, 0), + [1078] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 6, 0, 0), + [1080] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 6, 0, 0), + [1082] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 4, 0, 0), + [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 4, 0, 0), + [1086] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect_folded, 6, 0, 0), + [1088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect_folded, 6, 0, 0), + [1090] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 5, 0, 0), + [1092] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 5, 0, 0), + [1094] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset, 3, 0, 0), + [1096] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset, 3, 0, 0), + [1098] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect_folded, 5, 0, 0), + [1100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect_folded, 5, 0, 0), + [1102] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__plain_instr_folded, 5, 0, 0), + [1104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__plain_instr_folded, 5, 0, 0), + [1106] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 3, 0, 0), + [1108] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 3, 0, 0), + [1110] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 7, 0, 0), + [1112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 7, 0, 0), + [1114] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset, 1, 0, 0), + [1116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset, 1, 0, 0), + [1118] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 7, 0, 0), + [1120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 7, 0, 0), + [1122] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 7, 0, 0), + [1124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 7, 0, 0), + [1126] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 4, 0, 0), + [1128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 4, 0, 0), + [1130] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 4, 0, 0), + [1132] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 4, 0, 0), + [1134] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 7, 0, 0), + [1136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 7, 0, 0), + [1138] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__plain_instr_folded, 3, 0, 0), + [1140] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__plain_instr_folded, 3, 0, 0), + [1142] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr_folded, 1, 0, 2), + [1144] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr_folded, 1, 0, 2), + [1146] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 8, 0, 0), + [1148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 8, 0, 0), + [1150] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 3, 0, 0), + [1152] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 3, 0, 0), + [1154] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 4, 0, 0), + [1156] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 4, 0, 0), + [1158] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect_folded, 3, 0, 0), + [1160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect_folded, 3, 0, 0), + [1162] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 3, 0, 0), + [1164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 3, 0, 0), + [1166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 8, 0, 0), + [1168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 8, 0, 0), + [1170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 8, 0, 0), + [1172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 8, 0, 0), + [1174] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 8, 0, 0), + [1176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 8, 0, 0), + [1178] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 6, 0, 0), + [1180] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 6, 0, 0), + [1182] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 9, 0, 0), + [1184] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 9, 0, 0), + [1186] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_try_table_folded, 9, 0, 0), + [1188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_try_table_folded, 9, 0, 0), + [1190] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr_folded, 1, 0, 1), + [1192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr_folded, 1, 0, 1), + [1194] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr_folded, 1, 0, 3), + [1196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr_folded, 1, 0, 3), + [1198] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 10, 0, 0), + [1200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 10, 0, 0), + [1202] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_block_folded, 5, 0, 0), + [1204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_block_folded, 5, 0, 0), + [1206] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect_folded, 4, 0, 0), + [1208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect_folded, 4, 0, 0), + [1210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 6, 0, 0), + [1212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 6, 0, 0), + [1214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr_folded, 1, 0, 4), + [1216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr_folded, 1, 0, 4), + [1218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_loop_folded, 5, 0, 0), + [1220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_loop_folded, 5, 0, 0), + [1222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset, 4, 0, 0), + [1224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset, 4, 0, 0), + [1226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_folded, 5, 0, 0), + [1228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_folded, 5, 0, 0), + [1230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect_folded, 7, 0, 0), + [1232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect_folded, 7, 0, 0), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), + [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(719), + [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(721), + [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(720), + [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), + [1248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat2, 2, 0, 0), + [1250] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat2, 2, 0, 0), SHIFT_REPEAT(782), + [1253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), + [1255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(728), + [1257] = {.entry = {.count = 1, .reusable = false}}, SHIFT(782), + [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), + [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), + [1265] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 1, 0, 0), + [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [1269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(973), + [1271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(693), + [1275] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 1, 0, 0), SHIFT(1290), + [1278] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect, 1, 0, 0), + [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), + [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), + [1284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1206), + [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), + [1288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1135), + [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), + [1292] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1432), + [1295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), + [1297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), + [1299] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1432), + [1302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), + [1304] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 1, 0, 0), SHIFT(1317), + [1307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect, 1, 0, 0), + [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), + [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(705), + [1313] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 1, 0, 0), SHIFT(1350), + [1316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [1318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), + [1320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), + [1322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), + [1324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147), + [1326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), + [1328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(148), + [1330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(81), + [1332] = {.entry = {.count = 1, .reusable = false}}, SHIFT(738), + [1334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1370), + [1336] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1405), + [1338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(336), + [1340] = {.entry = {.count = 1, .reusable = false}}, SHIFT(351), + [1342] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1378), + [1344] = {.entry = {.count = 1, .reusable = false}}, SHIFT(6), + [1346] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1096), + [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), + [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(768), + [1352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), + [1354] = {.entry = {.count = 1, .reusable = false}}, SHIFT(131), + [1356] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [1358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132), + [1360] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77), + [1362] = {.entry = {.count = 1, .reusable = false}}, SHIFT(737), + [1364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1409), + [1366] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1381), + [1368] = {.entry = {.count = 1, .reusable = false}}, SHIFT(334), + [1370] = {.entry = {.count = 1, .reusable = false}}, SHIFT(398), + [1372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1321), + [1374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(7), + [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), + [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [1380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1559), + [1384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), + [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), + [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1477), + [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), + [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), + [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), + [1402] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1434), + [1405] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1434), + [1408] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1535), + [1410] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1581), + [1412] = {.entry = {.count = 1, .reusable = false}}, SHIFT(337), + [1414] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1427), + [1417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect, 2, 0, 0), + [1419] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1427), + [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect, 3, 0, 0), + [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [1426] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1197), + [1428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), + [1430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [1432] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1207), + [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1388), + [1436] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1489), + [1439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [1441] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 4, 0, 0), SHIFT(1489), + [1444] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__call_indirect, 4, 0, 0), + [1446] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1516), + [1449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat1, 2, 0, 0), + [1451] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1489), + [1454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat2, 2, 0, 0), + [1456] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1489), + [1459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1170), + [1461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 5, 0, 0), + [1463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), + [1465] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1488), + [1468] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1462), + [1471] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1488), + [1474] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_try_table_repeat1, 2, 0, 0), SHIFT_REPEAT(1282), + [1477] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_try_table_repeat1, 2, 0, 0), + [1479] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_try_table_repeat1, 2, 0, 0), + [1481] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1488), + [1484] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 4, 0, 0), SHIFT(1488), + [1487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem_list, 2, 0, 0), + [1489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 2, 0, 0), + [1491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), + [1493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 2, 0, 0), + [1495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [1497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 2, 0, 0), + [1499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), + [1501] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 2, 0, 0), + [1503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), + [1505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem_list, 1, 0, 0), + [1507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 3, 0, 0), + [1509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), + [1511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 3, 0, 0), + [1513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(891), + [1515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 3, 0, 0), + [1517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), + [1519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 3, 0, 0), + [1521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), + [1523] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1341), + [1525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [1527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1215), + [1529] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_try_table_repeat1, 2, 0, 0), SHIFT_REPEAT(1253), + [1532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 4, 0, 0), + [1534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), + [1536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 4, 0, 0), + [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [1540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 4, 0, 0), + [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [1544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 4, 0, 0), + [1546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), + [1548] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_elem_repeat2, 2, 0, 0), SHIFT_REPEAT(1206), + [1551] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_elem_repeat2, 2, 0, 0), + [1553] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 5, 0, 0), + [1555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), + [1557] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 5, 0, 0), + [1559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), + [1561] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 5, 0, 0), + [1563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), + [1565] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 6, 0, 0), + [1567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), + [1569] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 6, 0, 0), + [1571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), + [1573] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 6, 0, 0), + [1575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), + [1577] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 6, 0, 0), + [1579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), + [1581] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 7, 0, 0), + [1583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(908), + [1585] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 7, 0, 0), + [1587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), + [1589] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 7, 0, 0), + [1591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), + [1593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 7, 0, 0), + [1595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [1597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 8, 0, 0), + [1599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), + [1601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 8, 0, 0), + [1603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), + [1605] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 2, 0, 0), SHIFT(1504), + [1608] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1483), + [1611] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat1, 2, 0, 0), + [1613] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1504), + [1616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat2, 2, 0, 0), + [1618] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat1, 2, 0, 0), SHIFT_REPEAT(1464), + [1621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat1, 2, 0, 0), + [1623] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat2, 2, 0, 0), SHIFT_REPEAT(1562), + [1626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_field_func_repeat2, 2, 0, 0), + [1628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat2, 2, 0, 0), + [1630] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 4, 0, 0), SHIFT(1504), + [1633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__call_indirect, 4, 0, 0), + [1635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), + [1637] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1262), + [1639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(951), + [1641] = {.entry = {.count = 1, .reusable = false}}, SHIFT(497), + [1643] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__call_indirect, 3, 0, 0), SHIFT(1504), + [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 3, 0, 0), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1116), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), + [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1153), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1158), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1024), + [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), + [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), + [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1038), + [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 3, 0, 0), + [1688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), + [1690] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__instr, 1, 0, 0), + [1692] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 1, 0, 0), + [1694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 1, 0, 0), + [1696] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 1, 0, 0), + [1698] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 1, 0, 0), + [1700] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat3, 1, 0, 0), + [1702] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat1, 1, 0, 0), + [1704] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_block_repeat2, 1, 0, 0), + [1706] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 3, 0, 0), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), + [1710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 2, 0, 0), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), + [1714] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_param, 3, 0, 0), + [1716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_result, 3, 0, 0), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), + [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1100), + [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1115), + [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), + [1726] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_param, 4, 0, 0), + [1728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_result, 4, 0, 0), + [1730] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_use, 4, 0, 0), + [1732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 3, 0, 0), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [1736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_param, 5, 0, 0), + [1738] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_block, 8, 0, 0), + [1740] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_loop, 8, 0, 0), + [1742] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_if, 9, 0, 0), + [1744] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block_try_table, 9, 0, 0), + [1746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 2, 0, 0), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1173), + [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 8, 0, 0), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), + [1754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 2, 0, 0), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 2, 0, 0), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), + [1762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1214), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [1766] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__call_indirect_folded_repeat1, 2, 0, 0), SHIFT_REPEAT(1214), + [1769] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_indirect_folded_repeat1, 2, 0, 0), + [1771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(679), + [1773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1042), + [1775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [1777] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 4, 0, 0), + [1779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [1781] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 4, 0, 0), + [1783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1143), + [1785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), + [1787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 4, 0, 0), + [1789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1147), + [1791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 4, 0, 0), + [1793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), + [1795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1152), + [1797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [1799] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [1801] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), + [1803] = {.entry = {.count = 1, .reusable = false}}, SHIFT(111), + [1805] = {.entry = {.count = 1, .reusable = false}}, SHIFT(79), + [1807] = {.entry = {.count = 1, .reusable = false}}, SHIFT(735), + [1809] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), + [1811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 5, 0, 0), + [1813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), + [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 5, 0, 0), + [1817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), + [1819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1148), + [1821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 5, 0, 0), + [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), + [1825] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 5, 0, 0), + [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1166), + [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), + [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(711), + [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 6, 0, 0), + [1835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1179), + [1837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 6, 0, 0), + [1839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1181), + [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 6, 0, 0), + [1843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1183), + [1845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 6, 0, 0), + [1847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), + [1849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), + [1851] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1345), + [1853] = {.entry = {.count = 1, .reusable = false}}, SHIFT(491), + [1855] = {.entry = {.count = 1, .reusable = false}}, SHIFT(715), + [1857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), + [1859] = {.entry = {.count = 1, .reusable = false}}, SHIFT(162), + [1861] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), + [1863] = {.entry = {.count = 1, .reusable = false}}, SHIFT(163), + [1865] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74), + [1867] = {.entry = {.count = 1, .reusable = false}}, SHIFT(734), + [1869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335), + [1871] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [1873] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1390), + [1875] = {.entry = {.count = 1, .reusable = false}}, SHIFT(11), + [1877] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 7, 0, 0), + [1879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), + [1881] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 7, 0, 0), + [1883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), + [1885] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 7, 0, 0), + [1887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), + [1889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 7, 0, 0), + [1891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 8, 0, 0), + [1895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1194), + [1897] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch, 4, 0, 0), + [1899] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch, 4, 0, 0), + [1901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 9, 0, 0), + [1903] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__instr, 1, 0, 0), + [1905] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 1, 0, 0), + [1907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 1, 0, 0), + [1909] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 1, 0, 0), + [1911] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_type, 3, 0, 7), + [1913] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_type, 3, 0, 7), + [1915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_try_table, 1, 0, 0), + [1917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_type, 3, 0, 8), + [1919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_type, 3, 0, 8), + [1921] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_result, 3, 0, 0), + [1923] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_try_table_repeat1, 1, 0, 0), + [1925] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat3, 1, 0, 0), + [1927] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_module_field_func_repeat2, 1, 0, 0), + [1929] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_field_func_repeat2, 1, 0, 0), + [1931] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat1, 1, 0, 0), + [1933] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_block_repeat2, 1, 0, 0), + [1935] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1377), + [1937] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_global_type, 1, 0, 0), + [1939] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_type, 1, 0, 0), + [1941] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_try_table_repeat1, 1, 0, 0), + [1943] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local, 4, 0, 0), + [1945] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local, 4, 0, 0), + [1947] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_param, 4, 0, 0), + [1949] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_result, 4, 0, 0), + [1951] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_use, 4, 0, 0), + [1953] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch, 5, 0, 0), + [1955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch, 5, 0, 0), + [1957] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_global_type, 4, 0, 0), + [1959] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_type, 4, 0, 0), + [1961] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_type, 2, 0, 6), + [1963] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_type, 2, 0, 6), + [1965] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_type, 4, 0, 9), + [1967] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_type, 4, 0, 9), + [1969] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1270), + [1971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), + [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [1975] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local, 5, 0, 0), + [1977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local, 5, 0, 0), + [1979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_param, 5, 0, 0), + [1981] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_param, 3, 0, 0), + [1983] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1410), + [1985] = {.entry = {.count = 1, .reusable = false}}, SHIFT(712), + [1987] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local, 3, 0, 0), + [1989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local, 3, 0, 0), + [1991] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_block, 8, 0, 0), + [1993] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_loop, 8, 0, 0), + [1995] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_if, 9, 0, 0), + [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), + [2001] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1234), + [2003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), + [2005] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1317), + [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1608), + [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1219), + [2011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(530), + [2013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1243), + [2015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1470), + [2017] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1627), + [2019] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 2, 0, 8), + [2021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), + [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [2025] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 1, 0, 6), + [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1224), + [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), + [2031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1427), + [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1621), + [2035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_elem_repeat1, 2, 0, 0), + [2037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_elem_repeat1, 2, 0, 0), + [2039] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_elem_repeat1, 2, 0, 0), SHIFT_REPEAT(1236), + [2042] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 3, 0, 9), + [2044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 2, 0, 7), + [2046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [2048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1595), + [2050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1244), + [2052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), + [2054] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1416), + [2056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [2058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), + [2060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1536), + [2062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [2064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1322), + [2066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), + [2068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [2070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), + [2072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), + [2074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), + [2076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), + [2078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), + [2080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1225), + [2082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), + [2084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1230), + [2086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [2088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1617), + [2090] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1483), + [2092] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_elem_repeat1, 1, 0, 0), + [2094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_elem_repeat1, 1, 0, 0), + [2096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [2098] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1255), + [2100] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1438), + [2102] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1440), + [2104] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [2106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1370), + [2108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), + [2110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1577), + [2112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1333), + [2114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1504), + [2116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), + [2118] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_struct_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1594), + [2121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_struct_type_repeat1, 2, 0, 0), + [2123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1594), + [2125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), + [2129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1494), + [2131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1482), + [2133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), + [2135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2, 0, 0), + [2137] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2, 0, 0), SHIFT_REPEAT(1494), + [2140] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_rec_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1482), + [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_rec_type_repeat1, 2, 0, 0), + [2145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1597), + [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), + [2149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), + [2151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), + [2153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), + [2155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), + [2157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1553), + [2159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1629), + [2163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(715), + [2165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1318), + [2167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), + [2169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [2171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1381), + [2173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1612), + [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1623), + [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), + [2179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_global, 5, 0, 0), + [2181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_global, 5, 0, 0), + [2183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_import, 6, 0, 0), + [2185] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_import, 6, 0, 0), + [2187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), + [2189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [2191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), + [2193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), + [2195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(469), + [2197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1550), + [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [2201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 3, 0, 8), + [2203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), + [2205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_table, 4, 0, 0), + [2207] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_table, 4, 0, 0), + [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), + [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(706), + [2213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 6, 0, 0), + [2215] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 6, 0, 0), + [2217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 2, 0, 6), + [2219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_data_repeat1, 2, 0, 0), + [2221] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_data_repeat1, 2, 0, 0), SHIFT_REPEAT(1446), + [2224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_export, 5, 0, 0), + [2226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_export, 5, 0, 0), + [2228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [2230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_memory, 4, 0, 0), + [2232] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_memory, 4, 0, 0), + [2234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 4, 0, 0), + [2236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 4, 0, 0), + [2238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_def, 5, 0, 0), + [2240] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_def, 5, 0, 0), + [2242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_global, 4, 0, 0), + [2244] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_global, 4, 0, 0), + [2246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), + [2248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_data, 7, 0, 0), + [2250] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_data, 7, 0, 0), + [2252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), + [2254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_elem, 7, 0, 0), + [2256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_elem, 7, 0, 0), + [2258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), + [2260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(710), + [2262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [2264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_start, 4, 0, 0), + [2266] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_start, 4, 0, 0), + [2268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [2270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rec_type, 4, 0, 0), + [2272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rec_type, 4, 0, 0), + [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), + [2276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [2278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 7, 0, 0), + [2280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 7, 0, 0), + [2282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 5, 0, 0), + [2284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 5, 0, 0), + [2286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [2288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), + [2290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_def, 4, 0, 0), + [2292] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_def, 4, 0, 0), + [2294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_global, 7, 0, 0), + [2296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_global, 7, 0, 0), + [2298] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 4, 0, 0), + [2300] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 4, 0, 0), + [2302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_table, 7, 0, 0), + [2304] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_table, 7, 0, 0), + [2306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_memory, 7, 0, 0), + [2308] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_memory, 7, 0, 0), + [2310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), + [2312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 7, 0, 0), + [2314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 7, 0, 0), + [2316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_global, 6, 0, 0), + [2318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_global, 6, 0, 0), + [2320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(963), + [2322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), + [2324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 3, 0, 0), + [2326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 3, 0, 0), + [2328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__annotation_repeat1, 2, 0, 0), + [2330] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__annotation_repeat1, 2, 0, 0), SHIFT_REPEAT(1438), + [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), + [2335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), + [2337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), + [2339] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_table, 6, 0, 0), + [2341] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_table, 6, 0, 0), + [2343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), + [2345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(685), + [2347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), + [2349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(683), + [2351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rec_type, 3, 0, 0), + [2353] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rec_type, 3, 0, 0), + [2355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [2357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), + [2359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), + [2361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_elem, 4, 0, 0), + [2363] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_elem, 4, 0, 0), + [2365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__module_field, 1, 0, 0), + [2367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__module_field, 1, 0, 0), + [2369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_data, 3, 0, 0), + [2371] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_data, 3, 0, 0), + [2373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), + [2375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), + [2377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1004), + [2379] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 3, 0, 0), + [2381] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 3, 0, 0), + [2383] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mem_use, 4, 0, 0), + [2385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_use, 4, 0, 0), + [2387] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 8, 0, 0), + [2389] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 8, 0, 0), + [2391] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_table, 5, 0, 0), + [2393] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_table, 5, 0, 0), + [2395] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_data, 6, 0, 0), + [2397] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_data, 6, 0, 0), + [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [2401] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_elem, 3, 0, 0), + [2403] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_elem, 3, 0, 0), + [2405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_global, 8, 0, 0), + [2407] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_global, 8, 0, 0), + [2409] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_table, 8, 0, 0), + [2411] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_table, 8, 0, 0), + [2413] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 8, 0, 0), + [2415] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 8, 0, 0), + [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [2419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), + [2421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_memory, 6, 0, 0), + [2423] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_memory, 6, 0, 0), + [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(943), + [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), + [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(965), + [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(945), + [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), + [2435] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_elem, 6, 0, 0), + [2437] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_elem, 6, 0, 0), + [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), + [2441] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_data, 4, 0, 0), + [2443] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_data, 4, 0, 0), + [2445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat2, 1, 0, 0), + [2447] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_root_repeat2, 1, 0, 0), + [2449] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 4, 0, 9), + [2451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 11, 0, 0), + [2453] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 11, 0, 0), + [2455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_data, 5, 0, 0), + [2457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_data, 5, 0, 0), + [2459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1363), + [2461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1468), + [2463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_memory, 5, 0, 0), + [2465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_memory, 5, 0, 0), + [2467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 9, 0, 0), + [2469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 9, 0, 0), + [2471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_tag, 6, 0, 0), + [2473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_tag, 6, 0, 0), + [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), + [2477] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_elem, 5, 0, 0), + [2479] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_elem, 5, 0, 0), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), + [2483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 5, 0, 0), + [2485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 5, 0, 0), + [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), + [2489] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 3, 0, 7), + [2491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_field_func, 10, 0, 0), + [2493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_field_func, 10, 0, 0), + [2495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), + [2497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1587), + [2499] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_then_folded, 3, 0, 0), + [2501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_then_folded, 3, 0, 0), + [2503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1239), + [2505] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1517), + [2507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elem_expr, 1, 0, 0), + [2509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem_expr, 1, 0, 0), + [2511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_elem_repeat2, 1, 0, 0), + [2513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_elem_repeat2, 1, 0, 0), + [2515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__call_indirect_folded_repeat1, 1, 0, 0), + [2517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__call_indirect_folded_repeat1, 1, 0, 0), + [2519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_if_then_folded, 4, 0, 0), + [2521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_then_folded, 4, 0, 0), + [2523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1313), + [2525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(713), + [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module, 4, 0, 0), + [2529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module, 4, 0, 0), + [2531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module, 3, 0, 0), + [2533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module, 3, 0, 0), + [2535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 1, 0, 0), + [2537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 1, 0, 0), + [2539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elem_expr, 3, 0, 0), + [2541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem_expr, 3, 0, 0), + [2543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module, 5, 0, 0), + [2545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module, 5, 0, 0), + [2547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field, 5, 0, 0), + [2549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 5, 0, 0), + [2551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_share, 1, 0, 0), + [2553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_share, 1, 0, 0), + [2555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_struct_type_repeat1, 1, 0, 0), + [2557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_struct_type_repeat1, 1, 0, 0), + [2559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field, 4, 0, 0), + [2561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 4, 0, 0), + [2563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__annotation_repeat1, 1, 0, 0), + [2565] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__annotation_repeat1, 1, 0, 0), + [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1638), + [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), + [2571] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elem_expr, 4, 0, 0), + [2573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem_expr, 4, 0, 0), + [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), + [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(716), + [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [2581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(714), + [2583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), + [2585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(717), + [2587] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_data_repeat1, 1, 0, 0), + [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), + [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(712), + [2593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field, 3, 0, 0), + [2595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 3, 0, 0), + [2597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_rec_type_repeat1, 1, 0, 0), + [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_rec_type_repeat1, 1, 0, 0), + [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1551), + [2603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_tag, 3, 0, 0), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), + [2607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem, 3, 0, 0), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), + [2611] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_func_type, 5, 0, 0), + [2613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), + [2619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_type, 5, 0, 0), + [2621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_func, 7, 0, 0), + [2623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data, 4, 0, 0), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1599), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1210), + [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), + [2633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_else_folded, 3, 0, 0), + [2635] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [2637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 4, 0, 7), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1316), + [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1118), + [2643] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 4, 0, 8), + [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(585), + [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1289), + [2651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__composite_type, 1, 0, 0), + [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [2655] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_func_type, 3, 0, 0), + [2657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_type, 1, 0, 0), + [2659] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_addr_type, 1, 0, 0), + [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), + [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), + [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), + [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), + [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), + [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(739), + [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [2681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_func, 4, 0, 0), + [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [2685] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_use, 4, 0, 0), + [2687] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 0), + [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1598), + [2695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_global, 4, 0, 0), + [2697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cont_type, 4, 0, 0), + [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1600), + [2701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_table, 4, 0, 0), + [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [2705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_memory, 4, 0, 0), + [2707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_tag, 4, 0, 0), + [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1624), + [2711] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_func_type, 4, 0, 0), + [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(726), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), + [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1165), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(947), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), + [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [2733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_type, 6, 0, 0), + [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), + [2737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), + [2741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), + [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), + [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1415), + [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [2749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1556), + [2751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_if_else_folded, 4, 0, 0), + [2753] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_type, 4, 0, 0), + [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), + [2757] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__extern_type, 1, 0, 0), + [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), + [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), + [2765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_type, 4, 0, 0), + [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [2769] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_idx, 4, 0, 0), + [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1212), + [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1626), + [2775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), + [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), + [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), + [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1392), + [2785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data, 3, 0, 0), + [2787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [2789] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elem, 4, 0, 0), + [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), + [2793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [2795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_func, 5, 0, 0), + [2797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_type, 3, 0, 0), + [2799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_global, 5, 0, 0), + [2801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_page_size, 4, 0, 0), + [2803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_table, 5, 0, 0), + [2805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_memory, 5, 0, 0), + [2807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_tag, 5, 0, 0), + [2809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 5, 0, 9), + [2811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), + [2813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), + [2815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_func, 3, 0, 0), + [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1372), + [2819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [2821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), + [2823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [2825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1523), + [2829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mem_type, 3, 0, 6), + [2831] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_func, 6, 0, 0), + [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [2835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_type_tag, 6, 0, 0), + [2837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), + [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(703), + [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), + [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), + [2847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1527), + [2849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1531), + [2851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), + [2853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [2855] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_comment, 3, 0, 0), + [2857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__annotation, 3, 0, 0), + [2859] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_comment, 2, 0, 0), + [2861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__annotation, 2, 0, 0), + [2863] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_annotation_end, 1, 0, 0), +}; + +enum ts_external_scanner_symbol_identifiers { + ts_external_token__block_comment_content = 0, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token__block_comment_content] = sym__block_comment_content, +}; + +static const bool ts_external_scanner_states[2][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token__block_comment_content] = true, + }, +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_wat_external_scanner_create(void); +void tree_sitter_wat_external_scanner_destroy(void *); +bool tree_sitter_wat_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_wat_external_scanner_serialize(void *, char *); +void tree_sitter_wat_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_wat(void) { + static const TSLanguage language = { + .abi_version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .supertype_count = SUPERTYPE_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = (const void*)ts_lex_modes, + .lex_fn = ts_lex, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_wat_external_scanner_create, + tree_sitter_wat_external_scanner_destroy, + tree_sitter_wat_external_scanner_scan, + tree_sitter_wat_external_scanner_serialize, + tree_sitter_wat_external_scanner_deserialize, + }, + .primary_state_ids = ts_primary_state_ids, + .name = "wat", + .max_reserved_word_set_size = 0, + .metadata = { + .major_version = 0, + .minor_version = 1, + .patch_version = 0, + }, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/vendor/tree-sitter-wat/src/scanner.c b/vendor/tree-sitter-wat/src/scanner.c new file mode 100644 index 0000000..6923cf1 --- /dev/null +++ b/vendor/tree-sitter-wat/src/scanner.c @@ -0,0 +1,114 @@ +// Copied from tree-sitter-rust with modification. + +#include "tree_sitter/parser.h" + +enum TokenType { + BLOCK_COMMENT_CONTENT +}; + +void * tree_sitter_wat_external_scanner_create() { return 0; } +void tree_sitter_wat_external_scanner_destroy(void *payload) {} +unsigned tree_sitter_wat_external_scanner_serialize(void *payload, char *buffer) { + return 0; +} +void tree_sitter_wat_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {} + +typedef enum { + LeftParen, + LeftSemi, + Continuing, +} BlockCommentState; + +typedef struct { + BlockCommentState state; + unsigned nestingDepth; +} BlockCommentProcessing; + +static inline void process_left_paren(BlockCommentProcessing *processing, char current) { + if (current == ';') { + processing->nestingDepth += 1; + } + processing->state = Continuing; +}; + +static inline void process_left_semi(BlockCommentProcessing *processing, char current, TSLexer *lexer) { + if (current == ';') { + lexer->mark_end(lexer); + processing->state = LeftSemi; + return; + } + + if (current == ')') { + processing->nestingDepth -= 1; + } + + processing->state = Continuing; +} + +static inline void process_continuing(BlockCommentProcessing *processing, char current) { + switch (current) { + case '(': + processing->state = LeftParen; + break; + case ';': + processing->state = LeftSemi; + break; + } +} + +static inline bool process_block_comment(TSLexer *lexer, const bool *valid_symbols) { + char first = (char)lexer->lookahead; + lexer->advance(lexer, false); + + if (valid_symbols[BLOCK_COMMENT_CONTENT]) { + BlockCommentProcessing processing = {Continuing, 1}; + switch (first) { + case ';': + processing.state = LeftSemi; + if (lexer->lookahead == ')') { + return false; + } + break; + case '(': + processing.state = LeftParen; + break; + default: + processing.state = Continuing; + break; + } + + while (!lexer->eof(lexer) && processing.nestingDepth != 0) { + first = (char)lexer->lookahead; + switch (processing.state) { + case LeftParen: + process_left_paren(&processing, first); + break; + case LeftSemi: + process_left_semi(&processing, first, lexer); + break; + case Continuing: + lexer->mark_end(lexer); + process_continuing(&processing, first); + break; + default: + break; + } + lexer->advance(lexer, false); + if (first == ')' && processing.nestingDepth != 0) { + lexer->mark_end(lexer); + } + } + lexer->result_symbol = BLOCK_COMMENT_CONTENT; + return true; + } + + return false; +} + +bool tree_sitter_wat_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) { + if (valid_symbols[BLOCK_COMMENT_CONTENT]) { + return process_block_comment(lexer, valid_symbols); + } + + return false; +} diff --git a/vendor/tree-sitter-wat/src/tree_sitter/alloc.h b/vendor/tree-sitter-wat/src/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/vendor/tree-sitter-wat/src/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/vendor/tree-sitter-wat/src/tree_sitter/array.h b/vendor/tree-sitter-wat/src/tree_sitter/array.h new file mode 100644 index 0000000..a17a574 --- /dev/null +++ b/vendor/tree-sitter-wat/src/tree_sitter/array.h @@ -0,0 +1,291 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + _array__reserve((Array *)(self), array_elem_size(self), new_capacity) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) _array__delete((Array *)(self)) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + (_array__grow((Array *)(self), 1, array_elem_size(self)), \ + (self)->contents[(self)->size++] = (element)) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + _array__grow((Array *)(self), count, array_elem_size(self)); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), (self)->size, \ + 0, count, contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), _index, \ + old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element)) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((Array *)(self), array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self)) + +/// Swap one array with another +#define array_swap(self, other) \ + _array__swap((Array *)(self), (Array *)(other)) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +typedef Array(void) Array; + +/// This is not what you're looking for, see `array_delete`. +static inline void _array__delete(Array *self) { + if (self->contents) { + ts_free(self->contents); + self->contents = NULL; + self->size = 0; + self->capacity = 0; + } +} + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(Array *self, size_t element_size, + uint32_t index) { + assert(index < self->size); + char *contents = (char *)self->contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (self->size - index - 1) * element_size); + self->size--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) { + if (new_capacity > self->capacity) { + if (self->contents) { + self->contents = ts_realloc(self->contents, new_capacity * element_size); + } else { + self->contents = ts_malloc(new_capacity * element_size); + } + self->capacity = new_capacity; + } +} + +/// This is not what you're looking for, see `array_assign`. +static inline void _array__assign(Array *self, const Array *other, size_t element_size) { + _array__reserve(self, element_size, other->size); + self->size = other->size; + memcpy(self->contents, other->contents, self->size * element_size); +} + +/// This is not what you're looking for, see `array_swap`. +static inline void _array__swap(Array *self, Array *other) { + Array swap = *other; + *other = *self; + *self = swap; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void _array__grow(Array *self, uint32_t count, size_t element_size) { + uint32_t new_size = self->size + count; + if (new_size > self->capacity) { + uint32_t new_capacity = self->capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + _array__reserve(self, element_size, new_capacity); + } +} + +/// This is not what you're looking for, see `array_splice`. +static inline void _array__splice(Array *self, size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = self->size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= self->size); + + _array__reserve(self, element_size, new_size); + + char *contents = (char *)self->contents; + if (self->size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (self->size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + self->size += new_count - old_count; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/vendor/tree-sitter-wat/src/tree_sitter/parser.h b/vendor/tree-sitter-wat/src/tree_sitter/parser.h new file mode 100644 index 0000000..858107d --- /dev/null +++ b/vendor/tree-sitter-wat/src/tree_sitter/parser.h @@ -0,0 +1,286 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +typedef struct TSLanguageMetadata { + uint8_t major_version; + uint8_t minor_version; + uint8_t patch_version; +} TSLanguageMetadata; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +// Used to index the field and supertype maps. +typedef struct { + uint16_t index; + uint16_t length; +} TSMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; + uint16_t reserved_word_set_id; +} TSLexerMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t abi_version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexerMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; + const char *name; + const TSSymbol *reserved_words; + uint16_t max_reserved_word_set_size; + uint32_t supertype_count; + const TSSymbol *supertype_symbols; + const TSMapSlice *supertype_map_slices; + const TSSymbol *supertype_map_entries; + TSLanguageMetadata metadata; +}; + +static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + const TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + const TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_